diff --git a/.github/workflows/typecheck-client.yml b/.github/workflows/typecheck-client.yml
new file mode 100644
index 00000000..00b31b46
--- /dev/null
+++ b/.github/workflows/typecheck-client.yml
@@ -0,0 +1,32 @@
+name: Typecheck Client
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: typecheck-client-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  typecheck-client:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run client typecheck
+        run: npm run typecheck:client
diff --git a/.plans/clickable-terminal-urls-tests.md b/.plans/clickable-terminal-urls-tests.md
new file mode 100644
index 00000000..31599d19
--- /dev/null
+++ b/.plans/clickable-terminal-urls-tests.md
@@ -0,0 +1,279 @@
+# Clickable Terminal URLs -- Test Plan
+
+This test plan is aligned with the [implementation plan](./clickable-terminal-urls.md) and follows Red-Green-Refactor TDD order. Tests are grouped by implementation phase so the red phase of each feature can be written before the green.
+
+---
+
+## Phase 1: Utility Modules (terminal-hovered-url + url-utils)
+
+### 1.1 `test/unit/client/lib/terminal-hovered-url.test.ts` (new file)
+
+Tests for the module-level `Map<string, string>` that tracks the currently hovered URL per pane.
+
+| # | Test name | Verifies | Setup/Mocking | Assertions |
+|---|-----------|----------|---------------|------------|
+| 1 | `getHoveredUrl returns undefined for unknown paneId` | Default state is empty | None | `getHoveredUrl('pane-x')` returns `undefined` |
+| 2 | `setHoveredUrl stores a URL for a pane` | Basic set/get round-trip | `setHoveredUrl('pane-1', 'https://a.com')` | `getHoveredUrl('pane-1')` returns `'https://a.com'` |
+| 3 | `setHoveredUrl overwrites a previous URL for the same pane` | Overwrite semantics | Set twice with different URLs for same paneId | `getHoveredUrl` returns the second URL |
+| 4 | `clearHoveredUrl removes the stored URL` | Clear semantics | Set then clear | `getHoveredUrl` returns `undefined` |
+| 5 | `clearHoveredUrl on unknown paneId is a no-op` | No-op on missing key | `clearHoveredUrl('nonexistent')` | No error thrown |
+| 6 | `multiple panes are tracked independently` | Pane isolation | Set different URLs for `pane-1` and `pane-2` | Each `getHoveredUrl` returns its own URL; clearing `pane-1` does not affect `pane-2` |
+
+**Module isolation note**: Since the module uses a singleton `Map`, each test must call `clearHoveredUrl` in `afterEach` (or the module should export a `clearAll()` for testing). Alternatively, Vitest's `vi.resetModules()` can re-import a fresh instance per test. The implementation should decide; the tests should verify isolation either way.
+
+---
+
+### 1.2 `test/unit/client/lib/url-utils.test.ts` (new file)
+
+Tests for `findUrls(line: string): UrlMatch[]`.
+
+| # | Test name | Verifies | Input | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `finds a simple https URL` | Basic detection | `'Visit https://example.com for info'` | One match: `{ url: 'https://example.com', startIndex: 6, endIndex: 26 }` |
+| 2 | `finds a simple http URL` | http scheme | `'See http://example.org/page'` | One match with correct url, startIndex, endIndex |
+| 3 | `finds multiple URLs on one line` | Multi-match | `'Links: https://a.com and https://b.com/path'` | Two matches in order |
+| 4 | `strips trailing period from URL` | Trailing punct trim | `'Go to https://example.com/path.'` | URL is `'https://example.com/path'`, not `'https://example.com/path.'` |
+| 5 | `strips trailing comma` | Trailing punct trim | `'See https://example.com/path, then continue'` | URL does not end with `,` |
+| 6 | `strips trailing semicolon` | Trailing punct trim | `'URL: https://example.com;'` | URL does not end with `;` |
+| 7 | `strips trailing closing parenthesis` | Trailing punct trim | `'(see https://example.com/page)'` | URL is `'https://example.com/page'` (trailing `)` stripped) |
+| 8 | `strips trailing exclamation mark` | Trailing punct trim | `'Check https://example.com!'` | URL does not end with `!` |
+| 9 | `preserves URL with query string` | Query strings | `'https://example.com/search?q=test&page=1'` | Full URL including query preserved |
+| 10 | `preserves URL with fragment` | Fragments | `'https://example.com/docs#section-2'` | Fragment preserved |
+| 11 | `preserves URL with port number` | Ports | `'http://localhost:3000/api/health'` | Full URL including port preserved |
+| 12 | `preserves URL with path and trailing slash` | Trailing slash | `'https://example.com/path/'` | Trailing slash preserved |
+| 13 | `returns empty array for line with no URLs` | No false positives | `'Just a normal line of text'` | Empty array |
+| 14 | `does not match ftp or other schemes` | http/https only | `'Download from ftp://files.example.com/data'` | Empty array |
+| 15 | `handles URL at start of line` | Edge: start of line | `'https://example.com is great'` | One match with `startIndex: 0` |
+| 16 | `handles URL at end of line` | Edge: end of line | `'Visit https://example.com'` | One match, `endIndex` equals line length minus nothing |
+| 17 | `handles URL that is the entire line` | Edge: full line | `'https://example.com/path/to/resource'` | One match spanning entire line |
+| 18 | `does not match bare domains without scheme` | No scheme = no match | `'Go to example.com for info'` | Empty array |
+| 19 | `handles multiple trailing punctuation characters` | Multi-char trailing punct | `'See https://example.com/page.),'` | URL is `'https://example.com/page'` |
+| 20 | `preserves URL with encoded characters` | Percent-encoding | `'https://example.com/path%20with%20spaces'` | Full URL preserved |
+
+---
+
+## Phase 2: Left-Click Behavior Change (TerminalView)
+
+### 2.1 Update `test/unit/client/components/TerminalView.linkWarning.test.tsx` (existing file)
+
+These tests currently assert `window.open` is called. After the implementation change, link confirm and bypass should dispatch `splitPane` to create a browser pane instead.
+
+| # | Test name (existing, updated) | What changes | Assertions (before -> after) |
+|---|-------------------------------|--------------|------------------------------|
+| 1 | `opens link and closes modal on confirm` | Confirm now opens browser pane | **Remove**: `expect(windowOpenSpy).toHaveBeenCalledWith(...)`. **Add**: `store.getState().panes.layouts['tab-1']` is a split with second child having `content.kind === 'browser'` and `content.url === 'https://example.com/page'`. Modal still dismissed. |
+| 2 | `bypasses modal when warnExternalLinks is disabled` | Direct click opens browser pane | **Remove**: `expect(windowOpenSpy).toHaveBeenCalledWith(...)`. **Add**: `store.getState().panes.layouts['tab-1']` is a split with browser pane. `window.open` not called. Modal never shown. |
+| 3 | `shows confirm modal when link is clicked with warnExternalLinks enabled` | No change needed | Assertions remain the same (modal shown, window.open not called). Already correct. |
+| 4 | `does not open link on cancel` | No change needed | Assertions remain the same (no window.open, no pane split). Optionally verify layout remains a leaf. |
+
+**Setup/mocking**: The existing test infrastructure (`createStore`, `activateLinkHandler`, `terminalInstances`) is sufficient. The `windowOpenSpy` can remain for negative assertions (verifying `window.open` is NOT called). The key new assertion pattern is checking Redux state:
+
+```ts
+const layout = store.getState().panes.layouts['tab-1']
+expect(layout.type).toBe('split')
+if (layout.type === 'split') {
+  expect(layout.children[1]).toMatchObject({
+    type: 'leaf',
+    content: { kind: 'browser', url: expectedUrl, devToolsOpen: false },
+  })
+}
+```
+
+---
+
+### 2.2 Update `test/unit/client/components/TerminalView.keyboard.test.tsx` (existing file)
+
+The `registerLinkProvider` mock currently captures only the last registered provider. After the implementation adds a second provider (URL link provider), the mock needs to distinguish between the file path provider (registered first) and the URL provider (registered second).
+
+| # | Change description | What to modify |
+|---|-------------------|----------------|
+| 1 | Capture all registered link providers in an array | Change `capturedLinkProvider` from a single variable to `capturedLinkProviders: any[] = []`. Update the `registerLinkProvider` mock to `push` each provider onto the array. |
+| 2 | Expose named references | After render + `waitFor`, set `capturedFilePathProvider = capturedLinkProviders[0]` and `capturedUrlProvider = capturedLinkProviders[1]`. |
+| 3 | Update existing file path link tests | All existing tests that use `capturedLinkProvider` (lines 852-965) should use `capturedFilePathProvider` instead. No assertion changes needed -- only the variable name. |
+
+The existing keyboard tests (paste, copy, tab switching, search, etc.) should not need any changes since they test `attachCustomKeyEventHandler`, not link providers.
+
+---
+
+### 2.3 `test/unit/client/components/TerminalView.urlClick.test.tsx` (new file)
+
+Tests for the new left-click-opens-browser-pane behavior, including the URL link provider and the OSC 8 linkHandler changes.
+
+**Test infrastructure**: Follow the same pattern as `TerminalView.linkWarning.test.tsx` -- mock `@xterm/xterm`, `@xterm/addon-fit`, `@/lib/ws-client`, `@/lib/terminal-themes`, `ResizeObserver`, and render `TerminalView` inside a `Provider` with a Redux store.
+
+The `MockTerminal` should capture:
+- `options.linkHandler` (for OSC 8 hover/leave callbacks)
+- All `registerLinkProvider` calls (array, to get both file path and URL providers)
+- `buffer.active.getLine` should return text containing a URL for the URL provider tests
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `OSC 8 linkHandler.activate with warnExternalLinks=false dispatches splitPane with browser content` | Left-click opens browser pane (bypass mode) | Store with `warnExternalLinks: false`. Render TerminalView. Access `term.options.linkHandler.activate`. | Call `activate(mouseEvent, 'https://example.com')`. Check `store.getState().panes.layouts['tab-1']` has split with browser pane `{ kind: 'browser', url: 'https://example.com', devToolsOpen: false }`. `window.open` NOT called. |
+| 2 | `OSC 8 linkHandler.activate with warnExternalLinks=true shows modal, confirm opens browser pane` | Warning modal + browser pane | Store with default settings (warnExternalLinks=true). Activate link handler. | Modal shown. Click "Open link". Layout becomes split with browser pane. `window.open` NOT called. |
+| 3 | `OSC 8 linkHandler.hover sets hovered URL in module and data attribute` | Hover state tracking for OSC 8 | Render TerminalView. Get `term.options.linkHandler.hover`. | Call `hover(mouseEvent, 'https://hovered.example.com', mockRange)`. Verify `getHoveredUrl('pane-1')` returns `'https://hovered.example.com'`. Verify the wrapper div has `dataset.hoveredUrl === 'https://hovered.example.com'`. |
+| 4 | `OSC 8 linkHandler.leave clears hovered URL from module and data attribute` | Leave clears state | Set hovered URL via hover callback, then call leave. | `getHoveredUrl('pane-1')` returns `undefined`. Wrapper div does not have `dataset.hoveredUrl`. |
+| 5 | `URL link provider activate with warnExternalLinks=false dispatches splitPane with browser content` | Plain-text URL click opens browser pane | Mock `buffer.active.getLine` to return text with `'Visit https://detected.example.com here'`. Get the URL link provider (second `registerLinkProvider` call). Call `provideLinks` then `activate` on the returned link. | Layout becomes split with browser pane for `'https://detected.example.com'`. |
+| 6 | `URL link provider hover sets hovered URL in module and data attribute` | Hover on plain-text URL | Get URL link provider. Call `provideLinks`, then `hover` on the link. | `getHoveredUrl('pane-1')` set. Wrapper div `dataset.hoveredUrl` set. |
+| 7 | `URL link provider leave clears hovered URL` | Leave on plain-text URL | Hover then leave on URL link. | Hovered URL cleared. |
+| 8 | `URL link provider detects URLs in terminal buffer line` | URL detection integration | Mock buffer line with `'Check http://localhost:3000/api/health for status'`. | `provideLinks` callback receives a link array with text `'http://localhost:3000/api/health'` and correct range. |
+| 9 | `URL link provider returns undefined for lines with no URLs` | No false positives | Mock buffer line with `'Just a normal line with /tmp/file.txt'`. | `provideLinks` callback receives `undefined`. |
+| 10 | `terminal dispose clears hovered URL` | Cleanup on unmount | Set hovered URL via hover callback. Unmount the component. | `getHoveredUrl('pane-1')` returns `undefined`. |
+
+**Mocking details for wrapper div access**: To verify `dataset.hoveredUrl`, the test needs access to the DOM element with `data-context="terminal"`. Use `container.querySelector('[data-context="terminal"]')` from the render result, or `screen.getByTestId` if a testid is added. The existing pattern uses `data-context`, `data-pane-id`, and `data-tab-id` attributes which can be queried directly.
+
+---
+
+## Phase 3: Context Menu Integration
+
+### 3.1 `test/unit/client/components/context-menu/context-menu-utils.test.ts` (new file)
+
+Tests for `parseContextTarget` with the new `hoveredUrl` field on terminal targets.
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `parseContextTarget for Terminal returns hoveredUrl from dataset` | hoveredUrl extraction | `contextId = ContextIds.Terminal`, `data = { tabId: 'tab-1', paneId: 'pane-1', hoveredUrl: 'https://example.com' }` | Returns `{ kind: 'terminal', tabId: 'tab-1', paneId: 'pane-1', hoveredUrl: 'https://example.com' }` |
+| 2 | `parseContextTarget for Terminal returns hoveredUrl as undefined when not in dataset` | Optional field | `data = { tabId: 'tab-1', paneId: 'pane-1' }` (no `hoveredUrl`) | Returns `{ kind: 'terminal', tabId: 'tab-1', paneId: 'pane-1', hoveredUrl: undefined }` |
+| 3 | `parseContextTarget for Terminal returns null when tabId is missing` | Existing behavior preserved | `data = { paneId: 'pane-1' }` | Returns `null` |
+| 4 | `parseContextTarget for Terminal returns null when paneId is missing` | Existing behavior preserved | `data = { tabId: 'tab-1' }` | Returns `null` |
+| 5 | `parseContextTarget for Global returns global target` | Regression guard | `contextId = ContextIds.Global`, `data = {}` | Returns `{ kind: 'global' }` |
+| 6 | `parseContextTarget for Tab returns tab target with tabId` | Regression guard | `contextId = ContextIds.Tab`, `data = { tabId: 'tab-1' }` | Returns `{ kind: 'tab', tabId: 'tab-1' }` |
+
+**No mocking needed** -- `parseContextTarget` is a pure function.
+
+---
+
+### 3.2 `test/unit/client/components/context-menu/menu-defs.test.ts` (new file)
+
+Tests for `buildMenuItems` focusing on the terminal target with `hoveredUrl`. This is a new test file.
+
+**Setup**: Create helper functions:
+- `createMockActions()` -- returns a `MenuActions` object with `vi.fn()` for all actions (the current 67 + 4 new URL actions)
+- `createMockContext(overrides)` -- returns a `MenuBuildContext` with sensible defaults
+
+The mock actions object must match the full `MenuActions` type signature. The 4 new URL actions:
+```ts
+openUrlInPane: vi.fn(),
+openUrlInTab: vi.fn(),
+openUrlInBrowser: vi.fn(),
+copyUrl: vi.fn(),
+```
+
+The `getTerminalActions` mock should return a mock `TerminalActions` with `hasSelection: () => false` and stubs for all other methods.
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `terminal target with hoveredUrl includes URL menu items at the top` | URL items prepended | Target: `{ kind: 'terminal', tabId: 'tab-1', paneId: 'pane-1', hoveredUrl: 'https://example.com' }` | Items array starts with: `url-open-pane`, `url-open-tab`, `url-open-browser`, `url-copy`, then a separator `url-sep`, then the existing terminal clipboard items (`terminal-copy`, `terminal-paste`, `terminal-select-all`). |
+| 2 | `terminal target without hoveredUrl has no URL menu items` | No URL items when no hover | Target: `{ kind: 'terminal', tabId: 'tab-1', paneId: 'pane-1' }` (no `hoveredUrl`) | First item is `terminal-copy` (no `url-*` items). |
+| 3 | `url-open-pane item calls openUrlInPane with correct args` | Action wiring | Build items with `hoveredUrl: 'https://test.url'`. Find item with `id === 'url-open-pane'`. Call `onSelect`. | `mockActions.openUrlInPane` called with `('tab-1', 'pane-1', 'https://test.url')` |
+| 4 | `url-open-tab item calls openUrlInTab with correct args` | Action wiring | Same setup. Find item `url-open-tab`. Call `onSelect`. | `mockActions.openUrlInTab` called with `('https://test.url')` |
+| 5 | `url-open-browser item calls openUrlInBrowser with correct args` | Action wiring | Same setup. Find item `url-open-browser`. Call `onSelect`. | `mockActions.openUrlInBrowser` called with `('https://test.url')` |
+| 6 | `url-copy item calls copyUrl with correct args` | Action wiring | Same setup. Find item `url-copy`. Call `onSelect`. | `mockActions.copyUrl` called with `('https://test.url')` |
+| 7 | `URL items have correct labels` | UX labels | Build items with `hoveredUrl`. | Labels: `'Open URL in pane'`, `'Open URL in new tab'`, `'Open in external browser'`, `'Copy URL'` |
+| 8 | `existing terminal menu items still present after URL items` | No regression | Build items with `hoveredUrl`. | Items include `terminal-copy`, `terminal-paste`, `terminal-select-all`, `terminal-search`, `terminal-clear`, `terminal-reset`, `replace-pane` (by id). |
+
+---
+
+## Phase 4: Integration Tests (E2E-style with full component tree)
+
+### 4.1 `test/e2e/terminal-url-link-click.test.tsx` (new file)
+
+Integration test modeled after `terminal-file-link-same-tab.test.tsx`. Renders `TabContent` (the full pane layout) and verifies that clicking a URL in a terminal pane opens a browser pane in the same tab.
+
+**Test infrastructure**: Follow the exact same pattern as `terminal-file-link-same-tab.test.tsx`:
+- Mock `@/lib/ws-client`, `@/lib/api`, `@/lib/terminal-themes`, `@/components/terminal/terminal-runtime`, `@xterm/xterm` (with `linkProvidersByPaneId` to capture providers per pane), `@xterm/addon-fit`, `@xterm/xterm/css/xterm.css`
+- The buffer line mock should return a line containing a URL (e.g., `'Visit https://example.com/docs for more info'`)
+- Create a multi-pane layout store
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `clicking a URL in a nested terminal pane opens a browser pane on the same tab branch` | Full integration: URL detection + splitPane + layout | Multi-pane layout like `terminal-file-link-same-tab.test.tsx`. Buffer line contains `'Visit https://example.com/docs for more info'`. Access the URL link provider for `pane-clicked`. Call `provideLinks` + `activate`. | Tab count stays at 1. Active tab unchanged. Layout shows a new split off the clicked pane with `content: { kind: 'browser', url: 'https://example.com/docs', devToolsOpen: false }`. |
+| 2 | `OSC 8 link click in a nested pane opens browser pane (with warnExternalLinks disabled)` | OSC 8 integration path | Same multi-pane layout. `warnExternalLinks: false`. Access `linkHandler.activate` on the terminal for the clicked pane. | Browser pane created on the clicked pane's branch. |
+
+**Key difference from the file link test**: The file link test checks for `kind: 'editor'`; this test checks for `kind: 'browser'` with the URL. The mock buffer line must contain a URL instead of a file path.
+
+---
+
+### 4.2 `test/e2e/terminal-url-context-menu.test.tsx` (new file)
+
+Integration test modeled after `pane-context-menu-stability.test.tsx`. Renders `PaneLayout` inside `ContextMenuProvider` and verifies that URL-specific context menu items appear when right-clicking while a URL is hovered.
+
+**Test infrastructure**: Follow `pane-context-menu-stability.test.tsx`:
+- Mock all the same modules
+- Render with `ContextMenuProvider` wrapping `PaneLayout`
+- Use `userEvent` for right-click interaction
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `right-clicking a terminal pane with a hovered URL shows URL-specific menu items` | URL context menu integration | Render a two-pane layout. Set `data-hovered-url` on the terminal wrapper div (simulating hover state). Right-click the terminal surface. | Menu is visible. Menu contains items with labels: `'Open URL in pane'`, `'Open URL in new tab'`, `'Open in external browser'`, `'Copy URL'`. The standard terminal items (`Copy`, `Paste`, `Select all`, `Search`) are also present below. |
+| 2 | `right-clicking a terminal pane without a hovered URL shows no URL-specific items` | No URL items without hover | Same layout, no `data-hovered-url` attribute. Right-click. | Menu visible. No items with labels matching `'Open URL'` or `'Copy URL'`. Standard terminal items present. |
+| 3 | `selecting "Open URL in pane" creates a browser pane split` | End-to-end action | Render, set hovered URL, right-click, click `'Open URL in pane'`. | Menu closes. Layout becomes a split with a browser pane containing the hovered URL. |
+
+**Mocking details for `data-hovered-url`**: The hover/leave callbacks are triggered by xterm.js link events which are hard to simulate in JSDOM. Instead, imperatively set `dataset.hoveredUrl` on the terminal wrapper div before triggering the right-click. The context menu system reads from `dataset` via `copyDataset`, so this accurately tests the integration path. Access the wrapper via `container.querySelector('[data-pane-id="pane-1"][data-context="terminal"]')`.
+
+---
+
+## Phase 5: Cleanup and Edge Cases
+
+### 5.1 Additional tests in `TerminalView.urlClick.test.tsx`
+
+| # | Test name | Verifies | Setup | Assertions |
+|---|-----------|----------|-------|------------|
+| 1 | `hover state is cleared when terminal tab becomes hidden` | Tab switch cleanup | Render TerminalView (visible). Set hovered URL via hover callback. Re-render with `hidden={true}`. | `getHoveredUrl('pane-1')` returns `undefined`. |
+| 2 | `file path link provider is registered before URL link provider` | Registration order | Render TerminalView. Inspect `registerLinkProvider.mock.calls`. | First call registers a provider that detects file paths (test with a file path line). Second call registers a provider that detects URLs (test with a URL line). |
+
+---
+
+## Phase 6: Browser-Use E2E Smoke Test
+
+### 6.1 `test/e2e-browser/specs/terminal-url-click.spec.ts` (new file)
+
+A Playwright-based browser-use E2E test that verifies the URL click feature works in a real browser environment. This is a smoke test, not exhaustive.
+
+**Test infrastructure**: Uses the existing Playwright fixtures from `test/e2e-browser/helpers/fixtures.js`.
+
+| # | Test name | Verifies | Setup | Key assertions |
+|---|-----------|----------|-------|----------------|
+| 1 | `right-clicking a terminal shows URL menu items when hovering a link` | Full browser integration | Navigate to freshell. Wait for terminal. Need a URL to be present in terminal output. Use `send-keys` to echo a URL, then hover it. Right-click. | Context menu appears with `'Open URL in pane'`, `'Copy URL'` items. |
+
+**Note**: This test depends on xterm.js actually rendering and detecting URLs in a real browser. It may be fragile since it requires the URL to be linkified by xterm. If this proves too brittle, the test can be scoped to just verifying that the context menu renders the URL items when the `data-hovered-url` attribute is present (set via Playwright's `evaluate`), which tests the context menu integration path without depending on xterm link detection.
+
+---
+
+## Execution Order (TDD Phases)
+
+The implementation plan specifies this execution order, and the tests align to it:
+
+| Step | Red (write failing test) | Green (make it pass) |
+|------|--------------------------|----------------------|
+| 1 | Write tests 1.1 (`terminal-hovered-url.test.ts`) and 1.2 (`url-utils.test.ts`) | Implement `src/lib/terminal-hovered-url.ts` and `src/lib/url-utils.ts` |
+| 2 | Write tests 2.3 (`TerminalView.urlClick.test.tsx`) -- tests 1-2, 5, 8-9 (left-click + URL provider detection) | Update `TerminalView.tsx`: linkHandler activate/hover/leave, URL link provider, wrapperRef |
+| 3 | Update tests 2.1 (`TerminalView.linkWarning.test.tsx`) -- assertions change | Update `TerminalView.tsx`: warning modal confirm handler |
+| 4 | Update tests 2.2 (`TerminalView.keyboard.test.tsx`) -- provider capture | Already passing if mock is updated before green phase |
+| 5 | Write tests 2.3 remaining (`TerminalView.urlClick.test.tsx`) -- tests 3-4, 6-7, 10 (hover/leave/cleanup) | Already implemented in step 2 green phase |
+| 6 | Write tests 3.1 (`context-menu-utils.test.ts`) and 3.2 (`menu-defs.test.ts`) | Update context-menu-types, context-menu-utils, menu-defs, ContextMenuProvider |
+| 7 | Write tests 4.1 (`terminal-url-link-click.test.tsx`) and 4.2 (`terminal-url-context-menu.test.tsx`) | Already passing (integration of all prior phases) |
+| 8 | Write tests 5.1 (cleanup edge cases) | Add cleanup in TerminalView hidden effect and dispose |
+| 9 | Refactor phase -- no new tests, ensure all existing pass | |
+| 10 | Write test 6.1 (browser-use E2E smoke test) | Should pass against the completed implementation |
+
+---
+
+## New Test Files Summary
+
+| File | Type | Count |
+|------|------|-------|
+| `test/unit/client/lib/terminal-hovered-url.test.ts` | Unit | 6 tests |
+| `test/unit/client/lib/url-utils.test.ts` | Unit | 20 tests |
+| `test/unit/client/components/TerminalView.urlClick.test.tsx` | Unit | 12 tests |
+| `test/unit/client/components/context-menu/context-menu-utils.test.ts` | Unit | 6 tests |
+| `test/unit/client/components/context-menu/menu-defs.test.ts` | Unit | 8 tests |
+| `test/e2e/terminal-url-link-click.test.tsx` | Integration | 2 tests |
+| `test/e2e/terminal-url-context-menu.test.tsx` | Integration | 3 tests |
+| `test/e2e-browser/specs/terminal-url-click.spec.ts` | E2E smoke | 1 test |
+| **Total new tests** | | **58 tests** |
+
+## Modified Test Files Summary
+
+| File | Changes |
+|------|---------|
+| `test/unit/client/components/TerminalView.linkWarning.test.tsx` | 2 tests updated (assertions change from `window.open` to Redux state check) |
+| `test/unit/client/components/TerminalView.keyboard.test.tsx` | Mock updated to capture multiple link providers; variable references renamed |
diff --git a/.plans/clickable-terminal-urls.md b/.plans/clickable-terminal-urls.md
new file mode 100644
index 00000000..baa370d6
--- /dev/null
+++ b/.plans/clickable-terminal-urls.md
@@ -0,0 +1,489 @@
+# Clickable Terminal URLs
+
+## Goal
+
+URLs rendered in terminal panes (OSC 8 hyperlinks from Claude Code, opencode, Codex CLI, etc.) should be interactive:
+- **Left-click** opens the URL in a browser pane in the same tab (split right)
+- **Right-click** shows a context menu with URL-specific options: open in pane, open in tab, open in browser, copy URL
+
+Currently, the OSC 8 `linkHandler.activate` either shows a warning modal or calls `window.open`. Custom `registerLinkProvider` links (file paths) already open editor panes via `splitPane`. We extend both mechanisms.
+
+## Architecture Overview
+
+### Key Touch Points
+
+1. **`src/components/TerminalView.tsx`** -- Terminal creation, linkHandler, registerLinkProvider, hover state
+2. **`src/components/context-menu/context-menu-types.ts`** -- ContextTarget union type
+3. **`src/components/context-menu/context-menu-constants.ts`** -- ContextIds enum
+4. **`src/components/context-menu/context-menu-utils.ts`** -- parseContextTarget
+5. **`src/components/context-menu/menu-defs.ts`** -- buildMenuItems, MenuActions
+6. **`src/components/context-menu/ContextMenuProvider.tsx`** -- Action implementations, menu wiring
+7. **`src/store/panesSlice.ts`** -- splitPane action
+8. **`src/store/paneTypes.ts`** -- BrowserPaneContent
+
+### Design Decisions
+
+- **Hover state tracking via a module-level map** (not React state or Redux): The xterm.js `ILinkHandler.hover`/`leave` and `ILink.hover`/`leave` callbacks fire on raw DOM events, outside the React render cycle. We use a simple `Map<string, string>` keyed by paneId, storing the currently hovered URL. This avoids unnecessary re-renders and is synchronous to read at context-menu time.
+
+- **`ILinkHandler` vs `ILink` hover/leave signatures differ**: The `ILinkHandler` callbacks (OSC 8) receive `(event, text, range)` while `ILink` callbacks (custom link providers) receive `(event, text)`. Both are optional. Our implementations can safely ignore trailing params but should use the correct signature for each context to satisfy TypeScript.
+
+- **Context menu uses `dataset` attributes**: Following the existing pattern (e.g., `data-tab-id`, `data-pane-id`), we add `data-hovered-url` to the TerminalView wrapper div. The context menu system reads this from `dataset` when building menu items. This is the same pattern used by `data-context`, `data-tab-id`, etc.
+
+- **No new ContextTarget kind**: Rather than adding a new `terminal-url` kind, we enrich the existing `terminal` target with an optional `hoveredUrl` field. This is simpler and avoids splitting the terminal menu into two separate code paths. The `buildMenuItems` function checks for `hoveredUrl` in the dataset and conditionally prepends URL-specific items.
+
+- **New URL actions are separate from existing `splitPane` action in MenuActions**: The existing `actions.splitPane` in `ContextMenuProvider` always opens a picker pane (`{ kind: 'picker' }`). Our new `openUrlInPane` action dispatches `splitPaneAction` directly with browser content, bypassing the picker. This is intentional -- URL links should open directly in browser panes without a picker step.
+
+- **Left-click opens browser pane**: The `linkHandler.activate` callback dispatches `splitPane` with browser content, similar to how file path links dispatch `splitPane` with editor content. The warning modal is preserved as a setting but the default behavior changes from `window.open` to split-pane-browser.
+
+- **Warning modal still applies**: When `warnExternalLinks` is enabled, the warning modal still fires on left-click. But on confirm, it opens in a browser pane instead of `window.open`. The "Open in external browser" option in the context menu always uses `window.open`.
+
+---
+
+## Implementation Plan
+
+### Phase 1: Hover State Tracking
+
+**File: `src/lib/terminal-hovered-url.ts`** (new)
+
+Create a small utility module to track hovered URLs per pane:
+
+```ts
+const hoveredUrls = new Map<string, string>()
+
+export function setHoveredUrl(paneId: string, url: string): void {
+  hoveredUrls.set(paneId, url)
+}
+
+export function clearHoveredUrl(paneId: string): void {
+  hoveredUrls.delete(paneId)
+}
+
+export function getHoveredUrl(paneId: string): string | undefined {
+  return hoveredUrls.get(paneId)
+}
+```
+
+**File: `src/components/TerminalView.tsx`**
+
+1. Import the new module.
+
+2. Update the `linkHandler` on the Terminal constructor to add `hover` and `leave` callbacks:
+
+```ts
+linkHandler: {
+  activate: (_event: MouseEvent, uri: string) => {
+    // Changed: open in browser pane instead of window.open
+    if (warnExternalLinksRef.current !== false) {
+      setPendingLinkUriRef.current(uri)
+    } else {
+      dispatch(splitPane({
+        tabId,
+        paneId,
+        direction: 'horizontal',
+        newContent: { kind: 'browser', url: uri, devToolsOpen: false },
+      }))
+    }
+  },
+  // ILinkHandler.hover signature: (event, text, range) -- range unused
+  hover: (_event: MouseEvent, text: string, _range: import('@xterm/xterm').IBufferRange) => {
+    setHoveredUrl(paneId, text)
+  },
+  // ILinkHandler.leave signature: (event, text, range) -- all unused
+  leave: () => {
+    clearHoveredUrl(paneId)
+  },
+},
+```
+
+Note: The `leave` callback ignores all parameters. TypeScript allows fewer params than the signature requires, so `() => void` is valid for `(event, text, range) => void`.
+
+3. The existing file path link provider's `ILink` objects do not need `hover`/`leave` callbacks. File paths are not URLs, and they already open in editor panes. Leave them unchanged -- do **not** add empty hover/leave stubs.
+
+4. Add a URL link provider via `registerLinkProvider` to detect plain-text URLs in terminal output (non-OSC-8). This ensures URLs that are visually styled but not wrapped in OSC 8 sequences are also clickable. **Register this AFTER the file path provider** (currently at line 1044 in TerminalView.tsx) so file paths get higher priority (xterm.js: first registered = highest priority, since `linkProviders.push()` gives lower indices to earlier registrations and `_checkLinkProviderResult` checks lower indices first):
+
+```ts
+const urlLinkDisposable = typeof term.registerLinkProvider === 'function'
+  ? term.registerLinkProvider({
+    provideLinks(bufferLineNumber, callback) {
+      const bufferLine = term.buffer.active.getLine(bufferLineNumber - 1)
+      if (!bufferLine) { callback(undefined); return }
+      const text = bufferLine.translateToString()
+      const urls = findUrls(text)  // new utility function
+      if (urls.length === 0) { callback(undefined); return }
+      callback(urls.map((m) => ({
+        range: {
+          start: { x: m.startIndex + 1, y: bufferLineNumber },
+          end: { x: m.endIndex, y: bufferLineNumber },
+        },
+        text: m.url,
+        activate: (_event: MouseEvent) => {
+          if (warnExternalLinksRef.current !== false) {
+            setPendingLinkUriRef.current(m.url)
+          } else {
+            dispatch(splitPane({
+              tabId,
+              paneId,
+              direction: 'horizontal',
+              newContent: { kind: 'browser', url: m.url, devToolsOpen: false },
+            }))
+          }
+        },
+        hover: () => setHoveredUrl(paneId, m.url),
+        leave: () => clearHoveredUrl(paneId),
+      })))
+    },
+  })
+  : { dispose: () => {} }
+```
+
+5. Add cleanup in the terminal teardown to call `clearHoveredUrl(paneId)` and dispose the new link provider.
+
+6. Update the warning modal confirm handler to open in browser pane instead of `window.open`:
+
+```ts
+onConfirm={() => {
+  if (pendingLinkUri) {
+    dispatch(splitPane({
+      tabId,
+      paneId,
+      direction: 'horizontal',
+      newContent: { kind: 'browser', url: pendingLinkUri, devToolsOpen: false },
+    }))
+  }
+  setPendingLinkUri(null)
+}}
+```
+
+**File: `src/lib/url-utils.ts`** (new, or add to existing path-utils.ts)
+
+Create a `findUrls(line: string)` utility that finds http/https URLs in terminal output text. This mirrors `findLocalFilePaths` but for URLs. Must be careful to not match URLs that are already handled by `findLocalFilePaths` -- but since xterm.js link providers have priority ordering (last registered = highest priority), and file paths should not look like URLs, this should not conflict. If a range overlaps with a file path link, xterm's own priority system handles it.
+
+```ts
+export type UrlMatch = {
+  url: string
+  startIndex: number
+  endIndex: number
+}
+
+export function findUrls(line: string): UrlMatch[] {
+  // Match http:// and https:// URLs
+  // Use a regex similar to what WebLinksAddon uses
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`\[\]]+/g
+  const results: UrlMatch[] = []
+  let match
+  while ((match = urlRegex.exec(line)) !== null) {
+    // Trim trailing punctuation that's likely not part of the URL
+    let url = match[0]
+    const trailingPunct = /[.,;:!?)]+$/
+    const trailingMatch = trailingPunct.exec(url)
+    const endTrim = trailingMatch ? trailingMatch[0].length : 0
+    url = url.slice(0, url.length - endTrim)
+    results.push({
+      url,
+      startIndex: match.index,
+      endIndex: match.index + url.length,
+    })
+  }
+  return results
+}
+```
+
+### Phase 2: Context Menu Integration
+
+**File: `src/components/TerminalView.tsx`**
+
+Update the wrapper div to include the hovered URL in a data attribute. Since the hovered URL changes frequently (on mouse move) but we only need it at context-menu-open time, we use a ref-based approach to update a data attribute imperatively.
+
+1. Add a `wrapperRef` and attach it to the outer div (the one at approx line 2003 that currently has `data-context={ContextIds.Terminal}`, `data-pane-id={paneId}`, `data-tab-id={tabId}` but no ref):
+
+```tsx
+// In the component body (near containerRef at line 231):
+const wrapperRef = useRef<HTMLDivElement | null>(null)
+
+// In the JSX, add ref to the outer div:
+<div
+  ref={wrapperRef}
+  className={cn('h-full w-full', hidden ? 'tab-hidden' : 'tab-visible relative')}
+  data-context={ContextIds.Terminal}
+  data-pane-id={paneId}
+  data-tab-id={tabId}
+>
+```
+
+**Timing note**: The hover/leave callbacks reference `wrapperRef.current`, but are defined inside the terminal creation `useEffect` (line 976, dependency `[isTerminal]`). This is safe because `wrapperRef.current` is set during the initial render (before any user interaction can trigger hover events), and the callbacks only execute when the user hovers a link.
+
+2. In the hover/leave callbacks (both in the `linkHandler` and in the URL link provider), also update the DOM attribute:
+
+```tsx
+// For linkHandler hover/leave:
+hover: (_event, text, _range) => {
+  setHoveredUrl(paneId, text)
+  if (wrapperRef.current) {
+    wrapperRef.current.dataset.hoveredUrl = text
+  }
+},
+leave: () => {
+  clearHoveredUrl(paneId)
+  if (wrapperRef.current) {
+    delete wrapperRef.current.dataset.hoveredUrl
+  }
+},
+
+// For URL link provider ILink hover/leave:
+hover: () => {
+  setHoveredUrl(paneId, m.url)
+  if (wrapperRef.current) {
+    wrapperRef.current.dataset.hoveredUrl = m.url
+  }
+},
+leave: () => {
+  clearHoveredUrl(paneId)
+  if (wrapperRef.current) {
+    delete wrapperRef.current.dataset.hoveredUrl
+  }
+},
+```
+
+The `data-hovered-url` attribute will be picked up by the context menu system's `copyDataset` call, which copies all `dataset` properties from the nearest context element.
+
+**File: `src/components/context-menu/context-menu-types.ts`**
+
+Add `hoveredUrl` to the `terminal` kind in the ContextTarget union:
+
+```ts
+| { kind: 'terminal'; tabId: string; paneId: string; hoveredUrl?: string }
+```
+
+**File: `src/components/context-menu/context-menu-utils.ts`**
+
+Update `parseContextTarget` for the Terminal case to extract `hoveredUrl`:
+
+```ts
+case ContextIds.Terminal:
+  return data.tabId && data.paneId
+    ? {
+        kind: 'terminal',
+        tabId: data.tabId,
+        paneId: data.paneId,
+        hoveredUrl: data.hoveredUrl,
+      }
+    : null
+```
+
+**File: `src/components/context-menu/menu-defs.ts`**
+
+1. Add new URL-related actions to the `MenuActions` type:
+
+```ts
+openUrlInPane: (tabId: string, paneId: string, url: string) => void
+openUrlInTab: (url: string) => void
+openUrlInBrowser: (url: string) => void
+copyUrl: (url: string) => void
+```
+
+2. Update the `terminal` section of `buildMenuItems` to prepend URL-specific items when `hoveredUrl` is present:
+
+```ts
+if (target.kind === 'terminal') {
+  const terminalActions = actions.getTerminalActions(target.paneId)
+  const hasSelection = terminalActions?.hasSelection() ?? false
+  // ... existing code ...
+
+  const urlItems: MenuItem[] = target.hoveredUrl ? [
+    {
+      type: 'item',
+      id: 'url-open-pane',
+      label: 'Open URL in pane',
+      onSelect: () => actions.openUrlInPane(target.tabId, target.paneId, target.hoveredUrl!),
+    },
+    {
+      type: 'item',
+      id: 'url-open-tab',
+      label: 'Open URL in new tab',
+      onSelect: () => actions.openUrlInTab(target.hoveredUrl!),
+    },
+    {
+      type: 'item',
+      id: 'url-open-browser',
+      label: 'Open in external browser',
+      onSelect: () => actions.openUrlInBrowser(target.hoveredUrl!),
+    },
+    {
+      type: 'item',
+      id: 'url-copy',
+      label: 'Copy URL',
+      onSelect: () => actions.copyUrl(target.hoveredUrl!),
+    },
+    { type: 'separator', id: 'url-sep' },
+  ] : []
+
+  return [
+    ...urlItems,
+    ...buildTerminalClipboardItems(terminalActions, hasSelection),
+    // ... rest of existing items
+  ]
+}
+```
+
+**File: `src/components/context-menu/ContextMenuProvider.tsx`**
+
+Add the action implementations:
+
+```ts
+const openUrlInPane = useCallback((tabId: string, paneId: string, url: string) => {
+  dispatch(splitPaneAction({
+    tabId,
+    paneId,
+    direction: 'horizontal',
+    newContent: { kind: 'browser', url, devToolsOpen: false },
+  }))
+}, [dispatch])
+
+const openUrlInTab = useCallback((url: string) => {
+  const id = nanoid()
+  dispatch(addTab({ id, mode: 'shell' }))
+  dispatch(initLayout({ tabId: id, content: { kind: 'browser', url, devToolsOpen: false } }))
+}, [dispatch])
+
+const openUrlInBrowser = useCallback((url: string) => {
+  window.open(url, '_blank', 'noopener,noreferrer')
+}, [])
+
+const copyUrlAction = useCallback(async (url: string) => {
+  await copyText(url)
+}, [])
+```
+
+Define these as `useCallback` hooks alongside the existing action callbacks (before line 886). Then wire them into the `actions` object inside the `useMemo` at line 900 (add them after `copyAgentChatFilePath`). Also add them to the `useMemo` dependency array at lines 965-1019. The new action signatures should also be added to the `MenuActions` type in `menu-defs.ts`.
+
+Note: `copyText`, `nanoid`, `addTab`, `initLayout`, and `splitPaneAction` are all already imported in ContextMenuProvider.tsx -- no new imports needed for the action implementations.
+
+### Phase 3: Update Existing Tests
+
+**File: `test/unit/client/components/TerminalView.linkWarning.test.tsx`**
+
+The existing tests verify that:
+1. The warning modal shows when a link is clicked
+2. Confirming opens the link via `window.open`
+3. Canceling does not open the link
+4. Disabling `warnExternalLinks` opens immediately via `window.open`
+
+These tests need updating because:
+- The confirm action now dispatches `splitPane` instead of calling `window.open`
+- The bypass (warnExternalLinks=false) now dispatches `splitPane` instead of `window.open`
+
+Update the assertions to check that `store.getState().panes.layouts['tab-1']` becomes a split with a browser pane, instead of checking `window.open`.
+
+**File: `test/unit/client/components/TerminalView.keyboard.test.tsx`**
+
+This file captures `registerLinkProvider` callbacks via `capturedLinkProvider`. Since we add a new URL link provider (registered AFTER the file path provider), `registerLinkProvider` will now be called twice (file path provider first, then URL provider). The mock at line 58-61 saves only the last provider registered, which will now be the URL provider instead of the file path provider. The keyboard tests that use `capturedLinkProvider` to test file path link behavior (e.g., lines 863-937) will need the mock updated to capture the FIRST call (the file path provider), not the last. Recommended approach: store all registered providers in an array and expose separate references, e.g., `capturedFilePathProvider = calls[0]`, `capturedUrlProvider = calls[1]`.
+
+### Phase 4: New Tests
+
+**File: `test/unit/client/lib/terminal-hovered-url.test.ts`** (new)
+
+Test the module-level map utilities:
+- `setHoveredUrl` / `getHoveredUrl` / `clearHoveredUrl` basic CRUD
+- Multiple panes tracked independently
+- Clear removes correctly
+
+**File: `test/unit/client/lib/url-utils.test.ts`** (new, or extend path-utils test)
+
+Test `findUrls`:
+- Matches `http://` and `https://` URLs
+- Strips trailing punctuation (periods, commas, parentheses)
+- Returns correct startIndex/endIndex
+- Handles multiple URLs per line
+- Does not match non-URL text
+- Edge cases: URLs at end of line, URLs with query strings, URLs with fragments
+- Edge case: URLs with balanced parentheses (e.g., Wikipedia URLs like `https://en.wikipedia.org/wiki/Foo_(bar)`) -- the trailing punctuation stripper may over-trim. Decide whether to handle balanced parens or accept this limitation. A simple approach: only strip a trailing `)` if there is no matching `(` in the URL.
+
+**File: `test/unit/client/components/TerminalView.urlClick.test.tsx`** (new)
+
+Test the left-click behavior:
+- Clicking a URL (via linkHandler.activate) with warnExternalLinks=true shows modal, confirming dispatches splitPane with browser content
+- Clicking a URL with warnExternalLinks=false directly dispatches splitPane with browser content
+- Verify the browser pane content has the correct URL
+
+**File: `test/unit/client/components/context-menu/menu-defs.test.ts`** (new -- no existing test file for menu-defs currently exists in the repo)
+
+Create a new test file for `buildMenuItems`. The `createMockActions()` helper must include ALL actions from the current `MenuActions` type (67 actions as of now) plus the 4 new URL actions (`openUrlInPane`, `openUrlInTab`, `openUrlInBrowser`, `copyUrl`). The `createMockContext()` helper must include `aiEnabled: false` and all fields of `MenuBuildContext`.
+
+Add tests for the terminal context target with `hoveredUrl`:
+- When `hoveredUrl` is set, URL-specific menu items appear at the top
+- When `hoveredUrl` is not set, no URL items appear
+- Each URL menu item calls the correct action with the correct URL
+
+**File: `test/unit/client/components/context-menu/context-menu-utils.test.ts`** (new -- no existing test for this util)
+
+Test that `parseContextTarget` for Terminal correctly extracts `hoveredUrl` from dataset.
+
+### Phase 5: Hover State Cleanup and Edge Cases
+
+1. **Terminal dispose cleanup**: When the terminal is disposed (component unmount), `clearHoveredUrl(paneId)` must be called AND `delete wrapperRef.current.dataset.hoveredUrl` must be called. Add both to the existing cleanup function in TerminalView (approx line 1197, inside the `return () => { ... }` block). Also dispose the new URL link provider disposable.
+
+2. **Tab switch / hidden state**: When a terminal tab becomes hidden, the hover state should be cleared (the mouse is no longer over it). The existing `hiddenRef.current = hidden` effect (line 404-406) is a good place to add `clearHoveredUrl(paneId)` when `hidden` becomes true.
+
+3. **Multiple terminals**: Each terminal pane has its own paneId, so hover states are independent. The context menu reads from the correct pane's wrapper div.
+
+4. **OSC 8 vs custom link provider priority**: xterm.js checks OSC 8 links first, then registered link providers in order of registration (first registered = highest priority, since providers are pushed onto an array and iterated from index 0). Our custom URL link provider should be registered AFTER the file path provider (currently at line 1044) so file paths get higher priority if ranges ever overlap. However, the URL regex should not match file paths (no `http://` prefix), so overlap is unlikely. Concretely: insert the URL provider registration AFTER the existing file path provider block (after line 1076).
+
+5. **Data attribute cleanup on leave**: The `leave` callback must always clear the `data-hovered-url` attribute. If the user right-clicks while hovering a link and then moves the mouse away before the context menu renders, the attribute should already be set at the time of the `contextmenu` event because `leave` fires after the mouse moves off the link, not when the context menu opens.
+
+### Phase 6: Refactor and Polish
+
+After all tests pass, evaluate:
+- Whether `terminal-hovered-url.ts` should be merged into `pane-action-registry.ts` or kept separate
+- Whether the URL link provider logic should be extracted into its own file (similar to how file path links use `findLocalFilePaths` from `path-utils.ts`)
+- Whether the `findUrls` utility belongs in `path-utils.ts` or its own file
+
+**Update `docs/index.html`**: Per repo rules, update the docs mock to reflect the new clickable URL feature (URL context menu items in terminal panes). This is a significant user-facing UX change.
+
+---
+
+## File Change Summary
+
+### New Files
+- `src/lib/terminal-hovered-url.ts` -- Hover state tracking map
+- `src/lib/url-utils.ts` -- URL detection in terminal text
+- `test/unit/client/lib/terminal-hovered-url.test.ts`
+- `test/unit/client/lib/url-utils.test.ts`
+- `test/unit/client/components/TerminalView.urlClick.test.tsx`
+- `test/unit/client/components/context-menu/context-menu-utils.test.ts`
+- `test/unit/client/components/context-menu/menu-defs.test.ts` -- New test file for URL menu items + buildMenuItems
+
+### Modified Files
+- `src/components/TerminalView.tsx` -- linkHandler hover/leave, URL link provider, left-click behavior change, data attribute, wrapperRef
+- `src/components/context-menu/context-menu-types.ts` -- Add hoveredUrl to terminal target
+- `src/components/context-menu/context-menu-utils.ts` -- Parse hoveredUrl from dataset
+- `src/components/context-menu/menu-defs.ts` -- URL menu items, new MenuActions (4 new action signatures)
+- `src/components/context-menu/ContextMenuProvider.tsx` -- New action implementations + useMemo dependency array update
+- `test/unit/client/components/TerminalView.linkWarning.test.tsx` -- Update assertions for splitPane instead of window.open
+- `test/unit/client/components/TerminalView.keyboard.test.tsx` -- Update registerLinkProvider mock to handle two providers
+
+### Unchanged
+- `src/store/panesSlice.ts` -- Already has splitPane with browser content support
+- `src/store/paneTypes.ts` -- BrowserPaneContent already exists
+- `src/components/panes/BrowserPane.tsx` -- No changes needed
+
+---
+
+## Execution Order
+
+1. Red: Write `terminal-hovered-url.test.ts` and `url-utils.test.ts` (new utility tests)
+2. Green: Implement `terminal-hovered-url.ts` and `url-utils.ts`
+3. Red: Write `TerminalView.urlClick.test.tsx` (left-click opens browser pane)
+4. Green: Update `TerminalView.tsx` linkHandler activate/hover/leave and URL link provider
+5. Red: Update `TerminalView.linkWarning.test.tsx` (assertions change from window.open to splitPane)
+6. Green: Update TerminalView.tsx confirm handler
+7. Red: Write context menu tests (menu-defs with hoveredUrl, parseContextTarget)
+8. Green: Update context-menu-types, context-menu-utils, menu-defs, ContextMenuProvider
+9. Refactor: Clean up, extract shared patterns, review naming
+10. Full test suite run to verify no regressions
+
+## Risk Assessment
+
+- **Low risk**: The hover state tracking is purely additive and non-breaking.
+- **Medium risk**: Changing left-click behavior from `window.open` to splitPane changes existing UX. Mitigated by keeping the warning modal flow unchanged (just different confirm action).
+- **Low risk**: Context menu additions are purely additive to the existing terminal menu.
+- **Note**: The custom URL link provider (for non-OSC-8 URLs) overlaps with xterm.js's built-in URL detection. If xterm already detects and underlines URLs via its default link provider, our custom provider may create duplicate links. Need to verify xterm's default behavior -- if it already has a built-in web link matcher, we may only need the hover/leave callbacks on the existing `linkHandler` (for OSC 8) without adding a new `registerLinkProvider` for plain URLs. The built-in web link matcher in xterm.js is actually provided by `@xterm/addon-web-links`, which is not currently used (verified by grep). So we do need our own URL link provider.
diff --git a/docs/index.html b/docs/index.html
index 261665e9..01ff5125 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -785,6 +785,7 @@ <h2>Task Board</h2>
     { html: '  <span class="t-success">✓</span> Multi-tab terminal management', delay: 50 },
     { html: '  <span class="t-success">✓</span> Claude Code, Codex, Kimi, OpenCode &amp; more', delay: 50 },
     { html: '  <span class="t-success">✓</span> Split panes with browser views', delay: 50 },
+    { html: '  <span class="t-success">✓</span> Clickable URLs in terminal with right-click context menu', delay: 50 },
     { html: '  <span class="t-success">✓</span> In-pane terminal search with Ctrl+F', delay: 50 },
     { html: '  <span class="t-success">✓</span> Advanced OSC52 clipboard policy (Ask/Always/Never)', delay: 50 },
     { html: '  <span class="t-success">✓</span> Session history &amp; AI summaries', delay: 50 },
diff --git a/docs/lab-notes/2026-03-26-chrome-tooling-capabilities.md b/docs/lab-notes/2026-03-26-chrome-tooling-capabilities.md
new file mode 100644
index 00000000..67580a1d
--- /dev/null
+++ b/docs/lab-notes/2026-03-26-chrome-tooling-capabilities.md
@@ -0,0 +1,94 @@
+# Chrome Tooling Capabilities for Data Model Investigation
+
+**Date:** 2026-03-26
+**Context:** Testing what Chrome automation tools can actually observe to inform spike planning.
+
+## What Works
+
+### Redux Store Access (via React Fiber Tree)
+- **In dev mode**, React exposes `__reactContainer` on the root element
+- Can traverse fiber tree to find the Redux store on `memoizedProps.store`
+- Full `getState()` access — all 17 slices readable at any time
+- Can install `store.subscribe()` listeners to track state changes
+- Can install `store.dispatch` interceptor to log all actions with timestamps
+- Store reference survives as long as page doesn't reload (no HMR full refresh)
+- **Confirmed:** Captured all 17 slice keys: tabs, connection, sessions, settings, codingCli, panes, sessionActivity, terminalActivity, terminalDirectory, turnCompletion, terminalMeta, codexActivity, agentChat, paneRuntimeActivity, network, tabRegistry, extensions
+
+### Console Messages
+- `read_console_messages` captures console.log/error/warn/debug
+- Pattern filtering works
+- Can clear and re-read for incremental capture
+- **Limitation:** Freshell's client-logger wraps everything as "Object" in production build — need dev mode for readable messages
+
+### Network Requests (HTTP only)
+- `read_network_requests` captures all HTTP traffic including API calls
+- URL pattern filtering works
+- Can see bootstrap, session-directory, terminals, extensions API calls
+- **Limitation:** Does NOT capture WebSocket frames — only the HTTP upgrade request
+- **Workaround:** Use Redux dispatch interceptor to infer WS message flow (WS messages dispatch Redux actions)
+
+### Screenshots
+- Captures current visual state reliably
+- Useful for verifying UI indicators (offline banner, "Recovering terminal output..." label, spinner states)
+
+### JavaScript Execution
+- Full page context access
+- Can monkey-patch WebSocket constructor, store.dispatch, etc.
+- Can install persistent listeners (survive until page reload)
+- Can read/write localStorage
+
+## What Doesn't Work
+
+### WebSocket Frame Capture
+- `read_network_requests` doesn't show WS frames
+- Monkey-patching `WebSocket` constructor only catches NEW connections (not existing ones)
+- Would need to patch before page load to catch the initial connection — not possible with injected JS
+- **Workaround:** Redux dispatch log captures the effects of WS messages (actions dispatched in response to WS events)
+
+### Production Build Introspection
+- No `__reactFiber` on root element in production build
+- No Redux DevTools extension available
+- Console messages are opaque (minified object logs)
+- **Must use dev mode for investigation**
+
+### Surviving Page Reload
+- All injected JS (store ref, dispatch interceptor, WS patches) is lost on page reload
+- HMR partial updates in dev mode DO survive
+- Full Vite dev server restart triggers page reload — wipes everything
+- **Implication:** Can't instrument reconnect-after-server-restart scenarios without adding code to the source
+
+## Key Findings From Testing
+
+### Finding 1: Every Redux action fires twice
+When dispatch interceptor is installed, every action appears in the log twice within <5ms. This is the cross-tab sync mechanism re-dispatching received actions. This means the persistence middleware is doing double work on every state change.
+
+### Finding 2: Server restart reconnect is broken (or very slow) in dev mode
+- Killed dev server, restarted it. Client showed "Offline" for 35+ seconds
+- At +35s, a burst of activity: settings received, terminal re-created (new terminalId), pane content updated
+- But `connection/setStatus` never went back to `ready` — only `connection/setError` dispatched
+- The "Offline: input will queue until reconnected" banner persisted indefinitely
+- Client was stuck in a loop of thunk dispatches every ~5s without recovering
+- **This may be dev-mode-specific** (Vite proxy state changing) but worth investigating in production too
+
+### Finding 3: INVALID_TERMINAL_ID cascade confirmed
+- Console captured: `[TerminalView] [TRACE resumeSessionId] INVALID_TERMINAL_ID reconnecting`
+- After server restart, the pane content got a completely new `terminalId` (old: `bEGLueZVTpuqWPap5_xvJ`, new: `ESzM8YiOYes4_plRTEpuV`)
+- The terminal was re-created, but the connection never fully recovered
+- This is the exact cascade the plan predicted
+
+### Finding 4: "Recovering terminal output..." appears on fresh terminal creation
+- Even on the very first terminal creation (not a reconnect), the UI briefly shows "Recovering terminal output..." in the pane header
+- This suggests the recovery UI path fires even for new terminals, not just reconnects
+- May contribute to the "flaky feel" even in normal usage
+
+## Recommendations for Spike Approach
+
+1. **For reconnect measurement:** Must add instrumentation to source code (ws-client.ts, TerminalView.tsx) rather than relying on runtime injection — the injection gets lost on the page reloads that happen during reconnect scenarios.
+
+2. **For Redux action flow analysis:** Runtime dispatch interceptor works well for non-reload scenarios. Good for observing normal usage patterns, tab switches, sidebar interactions.
+
+3. **For visual regression:** Screenshots are reliable. Can capture before/during/after states of UI transitions.
+
+4. **For production testing:** Need to build with source maps or add a `window.__freshellStore` export to the store module. Production build gives no fiber access.
+
+5. **Should test production mode (npm start) separately from dev mode (npm run dev)** — the Vite proxy adds a layer that may mask or create different failure modes.
diff --git a/docs/lab-notes/2026-03-27-complete-characterization.md b/docs/lab-notes/2026-03-27-complete-characterization.md
new file mode 100644
index 00000000..4ac94a46
--- /dev/null
+++ b/docs/lab-notes/2026-03-27-complete-characterization.md
@@ -0,0 +1,102 @@
+# Freshell Complete System Characterization
+
+**Date:** 2026-03-27
+**Sources:** All 6 spikes + Chrome recon + user-reported symptoms
+
+---
+
+## Where We Are
+
+We have now characterized the entire system across four dimensions: performance, correctness, consistency, and user experience. The picture is clear enough to make architectural decisions.
+
+## The Fundamental Problem
+
+The system has **three tiers of consistency**, and only one of them is reliable:
+
+| Tier | What | Mechanism | Reliable? |
+|------|------|-----------|-----------|
+| **Strong** | Terminal I/O | Sequence numbers, gap detection, replay ring | Yes |
+| **Eventual** | Sessions, settings | Periodic broadcast → full HTTP re-fetch | Yes (5-8s lag) |
+| **Fire-and-forget** | Terminal metadata, layout mirror, pane state across tabs | Incremental updates, no snapshot, no reconciliation | **No** |
+
+Everything in Tier 3 can permanently diverge. The infrastructure to fix it exists (snapshot actions, list providers) but nobody calls the reconciliation paths.
+
+Compounding this: **cross-tab sync is non-atomic and last-write-wins with no version counter.** Tabs and panes are persisted together but hydrated separately via per-key storage events, creating windows of inconsistent state between the two. During these windows, pane content can be corrupted (Shell→Browser), layouts can break, and terminal IDs can diverge.
+
+---
+
+## Complete Issue Inventory
+
+### Data Integrity / Correctness
+
+| Issue | Mechanism | Severity |
+|-------|-----------|----------|
+| **Pane type corruption (Shell→Browser)** | `mergeTerminalState()` doesn't guard cross-kind transitions. Incoming pane with different `kind` silently overwrites. | Critical |
+| **Terminal metadata permanently diverges** | No initial snapshot on connect. No reconciliation on reconnect. `terminalMetaListProvider` is wired but never called. | High |
+| **Cross-tab sync is non-atomic** | `hydrateTabs` and `hydratePanes` dispatch separately from separate storage events. Window of inconsistent state between the two. | High |
+| **Terminal ID dual source of truth** | `tab.terminalId` and `pane.content.terminalId` set by separate dispatches, can diverge. Tab-level is legacy. | Medium |
+| **Cross-tab last-write-wins with no versioning** | Concurrent edits by different browser tabs lose one tab's changes. No vector clock or generation counter. | Medium |
+| **Pane close in one tab can break another tab** | Cross-tab hydration of removed layouts causes unmount cascades. Can trigger "offline reconnecting" state. | Medium |
+| **Layout mirror can go permanently stale** | One-way push, no retry. Lost `ui.layout.sync` = stale server state until next user interaction. | Low |
+| **`terminal.runtime.updated` is dead code** | Server broadcasts it, no client handler exists. | Low |
+
+### Performance / UX
+
+| Issue | Mechanism | Severity |
+|-------|-----------|----------|
+| **Session-directory over-polling** | Indexer broadcasts every 5-8s → client re-fetches full 73KB directory each time. ~660KB/min per browser tab idle. | High |
+| **Reconnect backoff overshoots** | 1s→2s→4s→8s exponential. 5s server restart → 15s+ client wait. | Medium |
+| **serverInstanceId persists to disk** | Client can't detect server restart. Must discover dead terminals one-by-one via INVALID_TERMINAL_ID. | Medium |
+| **Hidden tabs don't recover proactively** | Only active tab goes through reconnect recovery. Others broken until manually visited. | Medium |
+| **Session repair blocks terminal.create up to 10s** | Claude sessions serialize behind lock. Multiple terminals = stacked waits. | Medium |
+| **No terminal inventory in handshake** | Client discovers state reactively via errors instead of proactively. | Medium |
+| **Broadcast storm during reconnect** | 10 broadcasts for 5 terminals (2 per terminal). Feeds into action multiplication. | Low |
+| **Redundant sidebar session-directory fetches** | 2-4 fetches per sidebar click where 0-1 should suffice. | Low |
+| **"Recovering terminal output..." on fresh terminals** | Status/isAttaching race in create→attach flow. Brief flash on localhost, visible on LAN/VPN. | Low |
+| **/api/version hits GitHub uncached** | 227ms first call. Slowest request during page load. | Low |
+
+### User-Reported Symptoms Explained
+
+| Symptom | Root Cause |
+|---------|------------|
+| **Tab switch causes full conversation replay/fast-scroll** | Deferred reconnect: if a WS reconnect happened while the tab was hidden, the re-attach fires on tab switch with `viewport_hydrate` (full replay from seq 0). The cause (reconnect) is decoupled from the effect (replay on switch). |
+| **Closing panes in one tab breaks another tab** | Cross-tab sync hydrates removed layouts non-atomically, causing unmount cascades and transient "offline" state in the receiving tab. |
+| **Things feel flaky / get out of sync** | Tier 3 fire-and-forget state (metadata, layout mirror) has no self-healing. Cross-tab sync has no conflict resolution. Session-directory polling creates constant background churn. |
+
+---
+
+## What's Well-Designed (Keep These)
+
+- **Terminal I/O path**: WS → seq validation → RAF write queue → xterm.js. Zero Redux. 8ms/frame budget. Handles heavy output smoothly.
+- **Tab switch rendering**: CSS visibility toggle, no detach/reattach. Terminals stay attached in background.
+- **Page refresh recovery**: Pre-queued attach messages. 400ms to fully live.
+- **Session content caching** (PR #222): Stat-based LRU with request coalescing.
+- **Work scheduler** (PR #224): Priority lanes prevent starvation.
+- **Terminal create idempotency**: requestId-based dedup on server prevents duplicate terminals.
+- **Session delta sync**: Reduces ambient broadcast churn for session data.
+
+---
+
+## Architectural Root Causes (The "Why" Behind the Issues)
+
+### 1. No authoritative state snapshot on connect/reconnect
+The handshake sends `ready` + settings. The client must discover everything else reactively. Terminal metadata starts empty. Terminal existence is discovered via INVALID_TERMINAL_ID errors. The server has all this data and can serve it in <1ms but doesn't.
+
+### 2. Cross-tab sync is a bolt-on, not a first-class concern
+Tabs and panes are stored in separate localStorage keys, hydrated via separate storage events, merged with kind-unaware logic. The `mergeTerminalState` function guards terminal↔terminal and agent-chat↔agent-chat but silently accepts cross-kind overwrites. There's no version counter, no conflict resolution, no atomicity.
+
+### 3. Dual sources of truth with no reconciliation
+`tab.terminalId` vs `pane.content.terminalId`. Client localStorage vs server state. Multiple persistence middlewares with different debounce timers writing overlapping state. When these diverge, there's no mechanism to detect or correct the divergence.
+
+### 4. The server knows more than it tells
+The server tracks terminal metadata, terminal lifecycle, session state, and layout mirrors. But on reconnect, it only sends settings. Everything else must be discovered by the client through a series of individual requests and error responses.
+
+---
+
+## What We Still Don't Know
+
+- **Long-term stability (hours/days)**: All observations were minutes long. Memory leaks, handle leaks, gradual degradation unmeasured.
+- **Scale**: All tests used 3-5 terminals, 720 sessions. 20+ terminals, 5000+ sessions untested.
+- **Network conditions**: No testing on slow/lossy networks where the "Recovering" banner and reconnect timing would be more severe.
+- **Multi-device sync**: `tabs.sync.push` mechanism not tested.
+- **Reproducibility of pane corruption**: Mechanism identified via code analysis but not reliably reproduced in a test.
diff --git a/docs/lab-notes/2026-03-27-full-characterization.md b/docs/lab-notes/2026-03-27-full-characterization.md
new file mode 100644
index 00000000..ea7b7f23
--- /dev/null
+++ b/docs/lab-notes/2026-03-27-full-characterization.md
@@ -0,0 +1,147 @@
+# Freshell Stability: Full System Characterization
+
+**Date:** 2026-03-27
+**Sources:** Spikes 0 (Chrome recon), 1 (reconnect measurement), 2 (action storms), 3 (terminal rendering), 4 (server audit)
+
+---
+
+## Executive Summary
+
+We investigated three layers — reconnect/recovery, normal usage, and terminal rendering — to understand why Freshell feels flaky. The picture that emerges is:
+
+**The terminal rendering layer is solid.** Output bypasses Redux, goes direct to xterm.js via a well-designed RAF-batched write queue. Tab switches don't detach/reattach. Heavy output is smooth. This layer is not contributing to flakiness.
+
+**The server is fast.** All API endpoints <5ms. Event loop stays responsive. Session indexer is efficient. The server is not a bottleneck for any measured operation.
+
+**The flakiness has two distinct sources operating at different timescales:**
+
+1. **Steady-state: session-directory over-polling.** The session indexer broadcasts `sessions_changed` every 5-8 seconds. Every browser tab re-fetches the full `/api/session-directory` (73KB with ~720 sessions) on each broadcast. That's ~660KB/min of redundant traffic per tab, 9 HTTP requests/min during complete idle. This is the constant background hum of unnecessary work.
+
+2. **Catastrophic: reconnect cascade after server restart.** Exponential backoff overshoots (15s wait for a 5s restart), no server restart detection (serverInstanceId persists to disk), pane type corruption (Shell→Browser), hidden tabs left broken until visited, session repair blocking up to 10s per terminal. This is the dramatic failure that makes everything feel unreliable after any disruption.
+
+There is also one cosmetic issue that bridges both: **"Recovering terminal output..." flashes on every fresh terminal creation** due to a status/isAttaching race in the create→attach flow. It's brief on localhost but visible on LAN/VPN.
+
+---
+
+## Findings by Layer
+
+### Layer 1: Terminal Rendering (Spike 3) — HEALTHY
+
+| Aspect | Status | Details |
+|--------|--------|---------|
+| Output path | Clean | WS → seq validation → RAF write queue → xterm.write(). Zero Redux for shell output. |
+| Heavy output | Smooth | `find / \| head -50000` rendered without stutter. 8ms/frame write budget works. |
+| Tab switch rendering | Correct | CSS visibility toggle, no detach/reattach. No flash. |
+| Scrollback/replay | Working as designed | 256KB replay ring evicts oldest frames. Gap messages inform client. 8MB floor for coding CLIs. |
+| Queue backpressure | Handled | Transient queue buildup during heavy output, zero data drops. |
+
+**One bug found:** "Recovering terminal output..." banner on fresh terminals. Root cause traced to `TerminalView.tsx:1995` — the condition `status !== 'creating' && isAttaching` matches during the window between `terminal.created` (sets status='running') and `terminal.attach.ready` (clears isAttaching). One WS round-trip of visible recovery UI for brand-new terminals.
+
+### Layer 2: Normal Usage (Spike 2) — ONE MAJOR ISSUE
+
+| Aspect | Status | Details |
+|--------|--------|---------|
+| Tab switch actions | Fine | 2-4 actions per switch. No storm. |
+| Terminal output actions | Excellent | Zero Redux actions for shell output. |
+| Cross-tab sync | Moderate overhead | +4 actions on structural changes. Doesn't amplify idle polling. |
+| localStorage drift | None | Redux and localStorage stay consistent. |
+| **Session-directory polling** | **Problem** | **9 fetches/min per browser tab during idle. ~660KB/min on real instance.** |
+| Sidebar fetches | Redundant | 2-4 session-directory fetches per sidebar click where 0-1 should suffice. |
+
+**The session-directory polling is the single biggest steady-state issue.** Every `sessions_changed` broadcast (every 5-8s from the indexer) triggers a full re-fetch. With 2 browser tabs, that's ~16 requests/min. With 720 sessions at 73KB per response, this is significant wasted bandwidth and client-side JSON parsing.
+
+### Layer 3: Server (Spike 4) — FAST, BUT MISSING KEY HANDSHAKE DATA
+
+| Aspect | Status | Details |
+|--------|--------|---------|
+| API endpoints | <5ms all | settings <1ms, terminals <1ms, sessions <3ms, bootstrap ~9ms |
+| /api/version | Slow (227ms) | Hits GitHub API on every call. No server-side cache. |
+| Session indexer | 960ms startup | 728 files, consistent across runs. Event loop stays responsive. |
+| Memory | Reasonable | 37MB heap for 720 sessions. |
+| WS message handling | Concurrent | `void this.onMessage()` discards promise. Parallel for different terminals. |
+| Session repair | **Bottleneck** | Up to 10s wait per terminal.create for Claude sessions. Serializes behind lock. |
+| Handshake snapshot | **Missing** | No terminal inventory in `ready` message. Client discovers state reactively. |
+| Broadcast storm | During reconnect | 10 broadcasts for 5 terminals (2 per terminal: changed + runtime). |
+
+### Layer 4: Reconnect/Recovery (Spike 1) — MULTIPLE ISSUES
+
+| Scenario | Recovery Time | Issues Found |
+|----------|--------------|-------------|
+| WS drop (server alive) | ~1s | Clean. 1s backoff dominates, 8ms actual reconnect. |
+| Server restart | ~16s | Backoff overshoot, no restart detection, pane corruption, hidden tabs broken. |
+| Page refresh | ~400ms | Excellent. Pre-queued attach messages. No issues. |
+| Idle (external restart) | ~4.6s | Triple INVALID_TERMINAL_ID dispatch. Otherwise similar to restart. |
+
+---
+
+## Complete Bug/Issue Inventory
+
+### High Severity
+
+| Issue | Source | Impact |
+|-------|--------|--------|
+| Session-directory over-polling | Spike 2 | ~660KB/min wasted per browser tab. Constant unnecessary work. |
+| Pane type corruption on reconnect | Spike 1 | Shell pane becomes Browser pane. User loses their terminal. |
+| serverInstanceId persists to disk | Spike 1 | Client can't detect server restart. Must discover dead terminals one-by-one. |
+| Session repair blocks terminal.create up to 10s | Spike 4 | Multiple terminals for same session serialize. Likely cause of 35s recovery in spike 0. |
+| No terminal inventory in handshake | Spike 4 | Client discovers state reactively via errors instead of proactively. |
+
+### Medium Severity
+
+| Issue | Source | Impact |
+|-------|--------|--------|
+| Exponential backoff overshoots | Spike 1 | 15s wait for a 5s restart. Misses reconnect window by seconds. |
+| Hidden tabs don't recover proactively | Spike 1 | Broken state on every tab switch after server restart. |
+| Duplicate/triplicate INVALID_TERMINAL_ID | Spike 1 | Cross-tab sync amplifies error events 2-3x. Variable count suggests race. |
+| Broadcast storm during reconnect | Spike 4 | 10 broadcasts for 5 terminals. Feeds into Redux action multiplication. |
+| Redundant sidebar session-directory fetches | Spike 2 | 2-4 fetches per sidebar click where 0-1 should suffice. |
+
+### Low Severity
+
+| Issue | Source | Impact |
+|-------|--------|--------|
+| "Recovering terminal output..." on fresh terminals | Spike 1, 3 | Cosmetic flash. Brief on localhost, visible on LAN/VPN. Root cause fully traced. |
+| /api/version hits GitHub on every call | Spike 4 | 227ms uncached. Slowest request during page load. |
+| replayFromSeq > replayToSeq | Spike 1 | Misleading sequence numbers. Off-by-one or reporting issue. |
+| tabRegistry/setTabRegistrySyncError fires constantly | Spike 2 | Transient error set/cleared during normal navigation. Noise. |
+
+---
+
+## What We Didn't Investigate
+
+- **Scale beyond 5 terminals / 720 sessions.** All measurements used small terminal counts. Behavior at 20+ terminals or 5000+ sessions is unknown.
+- **Network conditions.** No testing on slow/lossy networks. The "Recovering" banner and reconnect timing would be more severe over WAN.
+- **Mobile/responsive.** Not in scope.
+- **Long-term stability (hours/days).** Idle observation was only 3-10 minutes. Memory leaks, handle leaks, or gradual degradation over hours are unmeasured.
+- **Multi-device sync (tabs.sync.push).** Not tested.
+
+---
+
+## What This Tells Us About the Architecture
+
+### What's well-designed
+- **Terminal output path.** WS → seq validation → RAF write queue → xterm.js. No Redux involvement. This is the right architecture for high-throughput data.
+- **Tab switch implementation.** CSS visibility toggle, no detach/reattach. Terminals stay attached in background. Smart.
+- **Page refresh recovery.** Pre-queuing attach messages before WS connects. 400ms to fully live.
+- **Session content caching (PR #222).** Stat-based LRU cache with request coalescing. Good pattern.
+- **Work scheduler (PR #224).** Priority lanes prevent starvation. Bootstrap always gets a slot.
+
+### What's not well-designed
+- **Session-directory polling model.** Broadcast fires every 5-8s → client does full re-fetch every time. No delta mechanism, no content hashing, no debouncing. The delta sync system (PR #222) exists for session snapshots but doesn't help for the directory re-fetch pattern.
+- **Reconnect recovery.** Reactive (discover errors one at a time) instead of proactive (server tells client what exists). The serverInstanceId-on-disk decision means the client can never skip the cascade.
+- **Cross-tab sync amplification.** Every Redux action dispatches through BroadcastChannel to other tabs. Error events, broadcast handlers, state updates — all multiplied. Not catastrophic but adds noise and wasted work.
+
+### The fundamental tension
+The system was designed for **eventual consistency** — the server broadcasts changes, the client reacts. This works for a collaborative document editor where changes trickle in. It does not work well for a terminal multiplexer where the user expects instant, deterministic state. Terminals either exist or they don't. The client shouldn't have to poll to find out.
+
+---
+
+## Recommended Next Steps
+
+This is the characterization complete. All four spikes are done. The full picture:
+
+1. **Steady-state problem:** Session-directory over-polling (~660KB/min per tab)
+2. **Catastrophic problem:** Reconnect cascade after server restart (15-35s recovery, pane corruption, hidden tabs broken)
+3. **Cosmetic problem:** "Recovering" banner on fresh terminals
+
+The characterization is clear enough to move to prioritized fix planning. But that's your call, Matt — I wanted to lay out the complete picture first so we're making decisions based on full data rather than partial observations.
diff --git a/docs/lab-notes/2026-03-27-investigation-plan.md b/docs/lab-notes/2026-03-27-investigation-plan.md
new file mode 100644
index 00000000..6613170d
--- /dev/null
+++ b/docs/lab-notes/2026-03-27-investigation-plan.md
@@ -0,0 +1,289 @@
+# Freshell Stability Investigation — Spike Plan
+
+**Date:** 2026-03-27
+**Branch:** data-model-review
+**Prior work:** See `docs/plans/2026-03-26-data-model-integrity.md` for the architectural review and `docs/lab-notes/2026-03-26-chrome-tooling-capabilities.md` for tooling recon.
+
+---
+
+## What we're trying to answer
+
+Freshell feels flaky. We have architectural theories about why (split-brain state, no reconnect snapshot, 5 persistence mechanisms, 17 Redux slices), and we confirmed one real failure during recon (server restart reconnect took 35s and never fully recovered). But we don't have a complete picture of all the ways things break. The goal of these spikes is to build that picture across three layers before committing to fixes:
+
+1. **Reconnect/crash recovery** — the dramatic failures
+2. **Normal usage performance** — the subtle death-by-a-thousand-cuts
+3. **Terminal rendering** — the xterm.js layer we haven't looked at yet
+
+---
+
+## Spike 1: Reconnect Cascade Measurement
+
+### What we want to know
+- Exactly how long the user sees broken/degraded UI after a reconnect, in each scenario
+- The full sequence of WS messages, Redux actions, and DOM state changes during recovery
+- Where time is actually spent (backoff? server processing? client rendering?)
+- Whether production mode and dev mode have different failure characteristics
+
+### Scenarios to test
+1. **WS drop, server still running** — the "network hiccup" case. Terminals are alive on the server, client just needs to re-attach. This should be fast.
+2. **Server restart** — everything on the server is gone. Client has stale terminalIds. This is the INVALID_TERMINAL_ID cascade.
+3. **Page refresh (F5)** — localStorage has layout, server has terminals. Client needs to re-hydrate and re-attach.
+4. **Long idle then interaction** — does anything go stale after 30+ minutes of no interaction?
+
+### Approach
+We can't use runtime Chrome injection for this because page reloads wipe our hooks. Need source-level instrumentation.
+
+**Add a `ReconnectTracer` module** — a simple singleton that writes timestamped events to `window.__reconnectTrace` (an array that builds up over time). It would hook into:
+
+- **ws-client.ts**: `disconnected`, `connecting`, `reconnect_attempt(n)`, `hello_sent`, `ready_received(serverInstanceId)`, `reconnect_failed(reason)`
+- **TerminalView.tsx**: `attach_sent(terminalId)`, `attach_ready(terminalId, replayFromSeq, replayToSeq)`, `invalid_terminal_id(terminalId)`, `create_sent(requestId)`, `terminal_created(terminalId)`, `first_output(terminalId)`
+- **App.tsx**: `settings_received`, `sessions_changed`, `terminals_changed`, `snapshot_received` (for when we add one)
+
+The tracer module would be a single file (`src/lib/reconnect-tracer.ts`), imported where needed. We'd add ~1-2 lines at each hook point. Easily removable after investigation.
+
+For each scenario, we:
+1. Build production (`npm run build`) and run with `npm start` on the worktree port
+2. Open in Chrome, create 3-5 terminals across 2-3 tabs
+3. Install Chrome runtime dispatch interceptor for action counts
+4. Trigger the scenario
+5. Wait for full recovery (or confirm it doesn't recover)
+6. Read `window.__reconnectTrace` via Chrome JS tool
+7. Screenshot the UI at 1s, 5s, 10s, 30s intervals
+8. Read server logs for the server's perspective
+
+**Data we record per scenario:**
+- Time from disconnect to ready (WS level)
+- Time from ready to first terminal attached (per-pane)
+- Time from first terminal attached to all panes live
+- Number of INVALID_TERMINAL_ID errors
+- Number of WS messages exchanged during recovery
+- Number of Redux actions dispatched during recovery
+- Visual state at key moments (screenshots)
+
+### Output
+Lab note with a timeline table per scenario. Something like:
+
+```
+Scenario: Server Restart (3 terminals, 2 tabs)
++0ms      server killed
++1200ms   WS disconnect detected
++2200ms   reconnect attempt 1 → failed (server not up)
++3200ms   reconnect attempt 2 → failed
+...
++8000ms   server up, reconnect attempt N → WS open
++8100ms   hello sent
++8300ms   ready received (new serverInstanceId)
++8350ms   terminal.attach sent for term-1 → INVALID_TERMINAL_ID
++8400ms   terminal.attach sent for term-2 → INVALID_TERMINAL_ID
++8420ms   terminal.create sent for new term (requestId: xxx)
++8600ms   terminal.created received (terminalId: yyy)
++8650ms   terminal.attach sent for yyy
++8700ms   terminal.attach.ready received
++8800ms   first output rendered
+Total recovery: 8800ms (7600ms waiting for server, 1200ms actual recovery)
+```
+
+This tells us whether the fix should focus on the backoff timing, the cascade, or both.
+
+---
+
+## Spike 2: Normal Usage Action Storms
+
+### What we want to know
+- How many Redux actions fire during common interactions (tab switch, sidebar click, terminal output burst)
+- Whether the double-dispatch from cross-tab sync is causing real performance issues
+- Whether idle time causes state drift between localStorage and Redux
+- How many HTTP requests the client makes during normal browsing of the sidebar
+
+### Approach
+This is all Chrome runtime — no source changes needed. The Redux store is accessible via fiber tree in dev mode, and we can install a dispatch interceptor that survives as long as the page doesn't reload.
+
+**Session protocol:**
+1. Start dev server on worktree port
+2. Open in Chrome, install dispatch interceptor and action counter
+3. Create 5 terminals across 3 tabs (shell, claude, codex mix)
+4. Baseline: record action count
+5. **Tab switch test:** Switch between all 3 tabs, record actions per switch
+6. **Sidebar test:** Click different sidebar sections (Coding Agents, Tabs, Panes, Projects), expand/collapse items, record actions and HTTP calls
+7. **Terminal output test:** Run `yes | head -1000` in a shell, record action count during output burst
+8. **Idle test:** Leave it alone for 10 minutes, then check action count, localStorage state, and Redux state for drift
+9. **Multi-tab test:** Open Freshell in a second browser tab, make changes in one, observe the other for sync delay/conflicts
+
+**Data we record:**
+- Actions per tab switch (with types)
+- Actions per sidebar interaction
+- Actions during terminal output burst
+- Background actions during idle (per minute)
+- Any localStorage/Redux divergence
+- Cross-tab sync delay
+
+### Output
+Lab note with action count tables and any anomalies found.
+
+---
+
+## Spike 3: Terminal Rendering Investigation
+
+### What we want to know
+- Why "Recovering terminal output..." appears on fresh terminal creation (not just reconnects)
+- Whether xterm.js re-renders are causing visible jank during normal output
+- Whether the scrollback buffer management causes issues (the 64KB ring buffer losing data, the scrollback setting propagation)
+- How the attach/snapshot flow interacts with xterm.js rendering
+
+### Approach
+Mix of code reading and Chrome observation.
+
+**Code review portion:**
+- Read TerminalView.tsx top to bottom, focusing on the attach flow and how output gets written to xterm
+- Read the `terminal-stream/broker.ts` attach method to understand the snapshot → replay → live transition
+- Trace the "Recovering terminal output..." label — what condition triggers it? When does it clear?
+- Understand the `seqState` tracking and how gaps are handled
+
+**Chrome observation portion (dev mode):**
+- Create a fresh terminal and observe:
+  - Does "Recovering" flash briefly? How long?
+  - What Redux actions fire during terminal creation?
+  - Is there a visible blank/flash before the prompt appears?
+- Run heavy output (`find / -type f 2>/dev/null`) and observe:
+  - Does the terminal stutter?
+  - Do Redux actions fire during output? (They shouldn't — output should go direct to xterm)
+  - Does the action counter spike during output bursts?
+- Tab away and back during heavy output:
+  - Does re-attaching cause a visible flash?
+  - How long does the "Recovering" state last?
+
+### Output
+Lab note documenting: the fresh terminal creation flow (why "Recovering" appears), any rendering issues found, and whether xterm.js performance is a real contributor to the flaky feel or a red herring.
+
+---
+
+## Spike 4: Server-Side Performance Audit
+
+### What we want to know
+- Whether the server is a bottleneck in any of the flows we're measuring
+- How the server handles multiple simultaneous terminal.attach requests on reconnect
+- Whether the JSONL session parsing is slow enough to affect sidebar responsiveness
+- What the server logs tell us during the reconnect cascade
+
+### Approach
+Primarily server log analysis and targeted timing.
+
+**During Spike 1 (reconnect):**
+- Read server logs for the reconnect window
+- Look for: slow request handling, WS message queueing, PTY spawn latency, session repair delays
+- Check if `terminal.create` and `terminal.attach` are handled concurrently or sequentially
+
+**Standalone tests:**
+- Start server with 10+ existing Claude sessions in `~/.claude/projects/`
+- Time the bootstrap/indexing phase
+- Time a `GET /api/session-directory` request
+- Time a `GET /api/terminals` request with 5, 10, 20 terminals
+- Check memory usage baseline and after 30 minutes of operation
+
+**Server log analysis:**
+- The server already has structured JSON logging. Check for:
+  - Request duration (`durationMs` in HTTP logs)
+  - WS message processing latency (if logged)
+  - Session indexer scan times
+  - Terminal registry operations
+
+### Output
+Lab note with server-side timing data. Answers: is the server fast enough that client-side fixes alone will solve the problem, or are there server bottlenecks too?
+
+---
+
+## Spike 5: State Consolidation Map (Code Review)
+
+### What we want to know
+- Which of the 17 Redux slices are necessary and which are redundant
+- Which persistence mechanisms can be eliminated
+- What the minimal state tree would look like if we designed it from scratch with current knowledge
+
+### Approach
+Pure code review — no running server needed.
+
+- Catalog each slice: what it stores, how it persists, whether it's server-derived or client-generated
+- Map the data flow: for each piece of state, trace where it comes from (server push? API call? localStorage? user action?) and where it goes (rendered? persisted? sent to server?)
+- Identify redundancy: state that exists in multiple places (e.g., `tab.terminalId` AND `pane.content.terminalId`)
+- Identify ephemeral state masquerading as persistent (things persisted to localStorage that are immediately overwritten from the server on load)
+- Propose a simplified tree grouping:
+  - **Server-authoritative** (terminals, sessions, metadata) — should come from server, cached locally
+  - **Client-local** (UI prefs, theme, font) — persists only in localStorage
+  - **Ephemeral** (rename requests, zoom state) — never persists
+  - **Derived** (sidebar items, activity indicators) — computed from other state, never stored
+
+### Output
+Lab note with the full catalog and a proposed simplification. This informs the Phase 3 implementation work.
+
+---
+
+## Spike 6: Server Snapshot Prototype (After 1-5)
+
+### What we want to know
+- Can the server assemble a complete state snapshot cheaply?
+- How large is it for realistic configurations?
+- Does it contain everything the client needs to skip the cascade?
+
+### Approach
+This is the first spike that writes real (non-instrumentation) code. Informed by all findings above.
+
+- Add `assembleStateSnapshot()` to ws-handler.ts
+- Include: terminal inventory (id, mode, status, title), terminal metadata (cwd, branch), sessions revision number, server instance ID
+- Measure assembly time and serialized size
+- Send after `ready` in handshake
+- On client: log receipt but don't process yet — compare to what the client currently discovers piecemeal
+
+### Output
+Lab note with feasibility assessment: size, timing, completeness. Go/no-go on the snapshot approach.
+
+---
+
+## Execution Order and Dependencies
+
+```
+Spike 1 (reconnect measurement)  ←── requires source changes, ~2-3 hours
+    ↓ informs
+Spike 4 (server audit)           ←── runs alongside spike 1, reads same logs
+
+Spike 2 (normal usage)           ←── Chrome only, no source changes, ~1-2 hours
+Spike 3 (terminal rendering)     ←── Chrome + code reading, ~1-2 hours
+
+Spike 5 (state map)              ←── pure code review, no dependencies, ~1 hour
+
+Spike 6 (snapshot prototype)     ←── depends on findings from 1-5
+```
+
+Spikes 1+4 can run together (same test sessions, different perspectives).
+Spikes 2 and 3 are independent of each other and of 1.
+Spike 5 is pure code review with no dependencies.
+Spike 6 waits for all others.
+
+I'd suggest running **1+4 first** (they're the most likely to reveal critical issues), then **2+3 in parallel**, then **5**, then **6**.
+
+---
+
+## Tools Summary
+
+| Tool | What it gives us | Limitations |
+|------|-----------------|-------------|
+| Chrome JS injection (dispatch interceptor) | Redux action flow, timing, counts | Lost on page reload. Dev mode only for store access. |
+| Chrome screenshots | Visual state at any moment | Can't capture transitions/animations |
+| Chrome console messages | Client-side errors and warnings | Messages are opaque "Object" in production |
+| Chrome network requests | HTTP API calls, timing | No WebSocket frames |
+| Source-level ReconnectTracer | Survives page reload, timestamps all reconnect events | Requires source changes (temporary) |
+| Server logs (structured JSON) | Server-side processing times, error details | Need to correlate with client timestamps |
+| `window.__reconnectTrace` | Full reconnect timeline accessible from Chrome | Only available after we add the tracer |
+| localStorage direct read | Persisted state snapshot | Only shows what was flushed (may lag behind Redux) |
+
+---
+
+## What this investigation does NOT cover
+
+To be clear about scope — these spikes are about diagnosing the existing problems, not about:
+- **Feature work** — no new features during investigation
+- **Network conditions** — we're not testing slow networks, high latency, or packet loss
+- **Scale testing** — we're not testing with 50+ terminals or 100+ sessions (would be a separate investigation)
+- **Security** — token handling, auth flows are not in scope
+- **Mobile/responsive** — mobile-specific issues are not in scope
+
+If any spike reveals a problem in these areas, we'll note it for future work.
diff --git a/docs/lab-notes/2026-03-27-spike-1-4-synthesis.md b/docs/lab-notes/2026-03-27-spike-1-4-synthesis.md
new file mode 100644
index 00000000..5eae63a0
--- /dev/null
+++ b/docs/lab-notes/2026-03-27-spike-1-4-synthesis.md
@@ -0,0 +1,118 @@
+# Spike 1+4 Synthesis: What We Know So Far
+
+**Date:** 2026-03-27
+**Sources:** spike-1 reconnect measurement, spike-4 server audit, spike-0 chrome recon
+
+---
+
+## The Picture So Far
+
+We've characterized the server and the reconnect/recovery paths. Here's what the data tells us, and — critically — what it doesn't.
+
+---
+
+## What We've Confirmed
+
+### The server is fast and not the bottleneck
+API endpoints respond in <5ms. Session indexer takes ~960ms on startup but doesn't block the event loop. Memory is reasonable (37MB heap for 720 sessions). The server can assemble terminal state in under 1ms. The machinery is there; it's just not being used at the right time.
+
+### The reconnect cascade is fast when it runs — the waiting is the problem
+The actual INVALID_TERMINAL_ID → create → attach cycle takes ~25ms. The time breakdown for a server restart recovery:
+- **93% backoff timers** (14.7s of 15.7s in measured scenario)
+- **5% waiting for first output** (~700ms)
+- **0.2% the cascade itself** (~25ms)
+
+The backoff overshoots because the exponential sequence (1s→2s→4s→8s) means a 5-second server restart causes 15+ seconds of client-side waiting. The server was ready by ~6s but the client didn't try again until 15s.
+
+### Page refresh is already fast (~400ms)
+The pre-queuing of attach messages before WS connects is smart design. No issues found.
+
+### Normal WS drops recover cleanly (~1s)
+The 1s base backoff dominates. Actual reconnection is 8ms. No errors.
+
+---
+
+## Bugs Found (Documented, Not Fixed)
+
+| Bug | Severity | Source |
+|-----|----------|--------|
+| **Pane type corruption during reconnect** — Shell becomes Browser pane | High | Spike 1, Scenario 2 |
+| **serverInstanceId persists to disk** — client can't detect server restart | High | Spike 1, Scenario 2 |
+| **Hidden tabs don't recover proactively** — broken until manually switched to | Medium | Spike 1, Scenario 2 |
+| **Duplicate/triplicate INVALID_TERMINAL_ID** — cross-tab sync re-dispatches 2-3x | Medium | Spike 1, Scenarios 2+4 |
+| **Exponential backoff overshoots** — misses reconnect window by seconds | Medium | Spike 1, Scenario 2 |
+| **"Recovering terminal output..." on fresh terminals** — recovery UI fires for new terminals | Low | Spike 1, baseline; Spike 0 |
+| **replayFromSeq > replayToSeq** — misleading sequence numbers | Low | Spike 1, Scenario 1 |
+| **/api/version hits GitHub on every call** — 227ms uncached network call | Low | Spike 4 |
+| **Session repair wait up to 10s per terminal.create** — serializes behind lock | High (for Claude sessions) | Spike 4 |
+| **Broadcast storm during reconnect** — 10 broadcasts for 5 terminals | Medium | Spike 4 |
+
+---
+
+## Architectural Gaps Confirmed
+
+### 1. No state snapshot on handshake
+The server sends `ready` + settings. The client has no idea what terminals exist. It discovers state reactively by trying to attach to stale IDs and getting errors back. The server has the data and can serve it in <1ms.
+
+### 2. serverInstanceId is not per-process
+It's loaded from `~/.freshell/instance-id` on disk, so it's the same across restarts. The client can't use it to distinguish "reconnect to same server" from "server restarted, everything's gone." This forces the client through the attach→INVALID→create cascade every time, even though the server could say "I'm a new instance" upfront.
+
+### 3. Cross-tab sync amplifies every event
+Every Redux action dispatches 2-3 times due to the BroadcastChannel/storage re-dispatch. This means every INVALID_TERMINAL_ID error, every broadcast from the server, every state update is multiplied. This is the mechanism behind the "action storms" we hypothesized but haven't yet measured in normal usage.
+
+### 4. Session repair is a hidden reconnect killer
+For Claude/Codex sessions, `terminal.create` can block up to 10s waiting for session repair. Multiple terminals for the same session serialize behind a lock. This is likely what caused the 35s recovery in the Chrome recon — it wasn't just backoff, it was backoff + repair waits stacking.
+
+---
+
+## What We Still Don't Know
+
+These are the gaps that spikes 2 and 3 are supposed to fill:
+
+### Normal usage degradation (Spike 2)
+- How many Redux actions fire per tab switch? Is the 2-3x multiplier from cross-tab sync actually causing visible jank, or is it just wasted work that the user doesn't notice?
+- Does idle state drift? Do localStorage and Redux diverge over time?
+- How much HTTP traffic does the sidebar generate during normal browsing? The 73KB session-directory response is fetched on every `sessions.changed` broadcast (every ~5s from the indexer). Is the client re-fetching 73KB every 5 seconds?
+- How does the system behave with 2+ browser tabs open? The cross-tab sync was designed for this, but we haven't tested it.
+
+### Terminal rendering (Spike 3)
+- Why does "Recovering terminal output..." appear on fresh terminals? This is confirmed in two independent observations but we don't know the code path that triggers it.
+- Does xterm.js stutter during heavy output? We haven't tested terminal rendering performance at all.
+- What happens visually when you tab-switch to a terminal that's been producing output in the background? Is there a visible repaint/flash?
+- Is the scrollback buffer management causing any issues (the 64KB ring buffer losing data)?
+
+### The "death by a thousand cuts" question
+The reconnect cascade is dramatic but rare (only happens on server restart). The everyday "flaky feel" might come from:
+- Action storms during normal tab switches
+- Sidebar re-fetching 73KB every 5 seconds
+- Terminal rendering hitches
+- The "Recovering" banner flashing on every terminal interaction
+- Cross-tab sync causing oscillation when multiple tabs are open
+
+**We don't have data on any of these yet.** Spikes 1 and 4 characterized the catastrophic failure path. We haven't characterized the steady-state experience.
+
+---
+
+## What the Data Does NOT Tell Us
+
+1. **Whether users primarily hit the server restart case.** If the server rarely restarts in practice, the 15s recovery might not be the main source of "flaky." The everyday experience (spikes 2+3) might matter more.
+
+2. **Whether the pane corruption bug is a one-off or systematic.** Shell→Browser corruption was observed once. Is this a consistent bug in the reconnect path, or a rare race condition?
+
+3. **Whether the 73KB session-directory payload is causing client-side parsing jank.** The server serves it fast, but the client parsing 73KB of JSON on every sidebar update might be noticeable.
+
+4. **What happens with 10+ terminals.** All measurements used 3-5 terminals. At 10+, the broadcast storm, the action multiplication, and the serial session repair could compound in ways we haven't measured.
+
+5. **Whether the cross-tab sync overhead is O(n) in the number of open browser tabs.** Two tabs might be fine; five might not.
+
+---
+
+## Recommended Next Step
+
+Run spikes 2 and 3. They target the steady-state experience that we haven't characterized. The reconnect path is well-understood now — we know what's slow and why. But we don't know if fixing it would make the product feel solid, or if there's a whole other category of problems in everyday usage that would still make it feel flaky.
+
+Specifically:
+- **Spike 2** should focus on: action counts per interaction, the 73KB re-fetch frequency, multi-tab behavior, and idle drift
+- **Spike 3** should focus on: the "Recovering" banner code path, tab-switch terminal rendering, and heavy output performance
+
+After those two, we'll have characterized all three layers (reconnect, normal usage, rendering) and can make an informed decision about what to fix and in what order.
diff --git a/docs/plans/2026-03-26-data-model-integrity.md b/docs/plans/2026-03-26-data-model-integrity.md
new file mode 100644
index 00000000..6bac1a32
--- /dev/null
+++ b/docs/plans/2026-03-26-data-model-integrity.md
@@ -0,0 +1,181 @@
+# Data Model Integrity: Investigation & Improvement Plan
+
+**Date:** 2026-03-26
+**Status:** Research phase — spikes and exploration before committing to implementation
+
+---
+
+## What We Know
+
+### The Symptom
+Freshell feels flaky compared to a desktop terminal. Panes flash through error states on reconnect, sidebar data goes stale, server restarts cause visible cascading recovery, and cross-tab state can oscillate.
+
+### The Root Cause: Split-Brain by Design
+There is no single source of truth. The client (localStorage + Redux) owns tabs, pane layouts, and terminal bindings. The server (in-memory) owns terminal processes, scrollback buffers, and session data. Neither side has the full picture.
+
+Reconciliation is **reactive** — the client discovers problems one at a time via INVALID_TERMINAL_ID errors — rather than **proactive** — the server telling the client what's alive on connect.
+
+### Specific Mechanisms Contributing to Flakiness
+
+1. **No state snapshot on reconnect.** After WebSocket `ready`, the server sends settings and that's it. The client must:
+   - Re-attach each terminal individually (each can fail with INVALID_TERMINAL_ID)
+   - Wait for `terminals.changed` / `sessions.changed` broadcasts
+   - Poll APIs to discover what exists
+   - This means every reconnect has a visible "partially stale" window
+
+2. **Ephemeral broadcast events with no replay.** Terminal titles, metadata (cwd, git branch), session lists, and terminal directory changes are broadcast as fire-and-forget events. Miss one during a disconnect and you stay stale until the next broadcast — which may never come.
+
+3. **Cascading error recovery.** Each pane independently discovers its terminal is gone, then goes through 3-4 round trips (attach → error → new createRequestId → create → attach). All visible to the user.
+
+4. **Five persistence/sync mechanisms:**
+   - persistMiddleware (tabs/panes → localStorage, 500ms debounce)
+   - sessionActivityPersistMiddleware (activity → localStorage, 5000ms debounce)
+   - browserPreferencesPersistenceMiddleware (prefs → localStorage, 500ms debounce)
+   - crossTabSync (BroadcastChannel + storage events)
+   - layoutMirrorMiddleware (layout → server via WS, 200ms debounce)
+
+   Each has its own debounce, its own storage key, and its own merge strategy. They can conflict.
+
+5. **17 Redux slices** with inconsistent persistence strategies — some persisted, some not, some debounced at different intervals, some server-derived, some client-generated.
+
+### What the Recent Upstream PRs Contributed
+
+- **#222 (session content caching):** Good transparent read-through cache with stat-based invalidation and request coalescing. Proves the team can do caching right. Doesn't help reconnect but is a pattern to build on.
+- **#224 (search starvation):** Bumps foreground concurrency to 3 so bootstrap can't be starved by deep searches. Directly helps reconnect reliability.
+- **#220 (extensions):** No data model impact.
+
+### What Prior Plans Already Fixed
+
+The team has been aware of symptoms and fixed many specific bugs:
+- Sessions delta sync (2026-02-07): COMPLETE — reduced bandwidth from session broadcasts
+- Attach generation tokens (2026-02-23): Prevents stale-message races during reconnect
+- Session restore consistency (2026-02-08): Fixed 7 specific restore bugs
+- Pane-first terminal ownership (2026-01-29): Correct ownership model (panes own terminals, not tabs)
+- WS attach chunking (2026-02-10): Transport-layer backpressure handling
+
+These were good fixes but they're patches on the symptom. The architectural root cause (split-brain, no snapshot, reactive recovery) remains.
+
+---
+
+## What We Think (Hypotheses to Validate)
+
+### H1: A server state snapshot on reconnect would eliminate most visible flakiness
+**Thesis:** If the server sends a complete terminal inventory + metadata + session summary immediately after `ready`, the client can skip the cascading discovery phase. Panes that reference dead terminals can go straight to re-creation without the attach → error → create dance.
+
+**What we need to know:**
+- How large is the snapshot for realistic terminal counts (5, 20, 50)?
+- How long does assembly take?
+- Does sending it in the handshake add noticeable latency?
+
+### H2: The server can be the layout source of truth
+**Thesis:** The server already receives layout mirrors via `ui.layout.sync`. If it stores and returns these, localStorage becomes a fallback cache rather than source of truth. This eliminates cross-tab merge conflicts and stale-layout problems.
+
+**What we need to know:**
+- What does the layout mirror actually contain vs. what the full pane tree needs?
+- Is there a gap? How big?
+- Memory/storage cost of one layout per device?
+- What happens on server restart — do we need disk persistence?
+
+### H3: The 17 slices / 5 persistence mechanisms can be dramatically simplified
+**Thesis:** Many slices exist because the system grew organically. Several are redundant with server state or could be derived from a single authoritative source.
+
+**What we need to know:**
+- Which slices are purely server-derived and don't need client persistence?
+- Which are legitimately client-local (UI prefs)?
+- Can we get down to 2 persistence mechanisms (one for UI prefs, one for server-sync)?
+
+### H4: Revision-gapped event replay would close the "missed broadcast" hole
+**Thesis:** If broadcasts include revision numbers and the client tracks its last-seen revision, it can detect gaps and request a catch-up snapshot instead of staying stale.
+
+**What we need to know:**
+- Do the existing `terminals.changed` and `sessions.changed` revision numbers already support this?
+- What's the cost of the server maintaining a short event log for catch-up?
+
+---
+
+## Research Spikes
+
+### What We Learned From Chrome Tooling Recon (2026-03-26)
+
+Before defining spikes, we tested what Chrome automation can actually observe. Key findings:
+
+**Capabilities confirmed:**
+- Can access full Redux store (all 17 slices) via React fiber tree in dev mode
+- Can install dispatch interceptors to log all actions with timestamps
+- Can read localStorage, capture console messages, take screenshots
+- Can observe HTTP API calls (bootstrap, session-directory, terminals)
+
+**Limitations discovered:**
+- Cannot capture WebSocket frames directly (only HTTP). Must infer WS traffic from Redux actions.
+- All injected instrumentation is lost on page reload — so reconnect-after-server-restart scenarios wipe our observers at the worst possible moment.
+- Production build has no fiber access, no readable console messages. Must use dev mode.
+
+**Real findings from ad-hoc testing:**
+1. **Every Redux action fires twice** — the cross-tab sync mechanism re-dispatches. 5 persistence mechanisms doing double work.
+2. **Server restart reconnect took 35+ seconds** and then didn't fully recover. Connection status stayed `disconnected` despite terminal re-creation activity. The `INVALID_TERMINAL_ID reconnecting` log appeared, a new terminalId was assigned, but the connection never went back to `ready`.
+3. **"Recovering terminal output..." appears even on fresh terminal creation**, not just reconnects. Contributes to the flaky feel in normal usage.
+4. **Dev vs production mode may have different failure characteristics** due to Vite proxy layer.
+
+**Implication for spikes:** Runtime injection alone can't measure the reconnect cascade reliably — the page reload wipes our hooks. We need to add lightweight instrumentation to the actual source code (removable after investigation), and we need to test in production mode separately from dev mode.
+
+See: `docs/lab-notes/2026-03-26-chrome-tooling-capabilities.md`
+
+---
+
+**Full spike details:** See `docs/lab-notes/2026-03-27-investigation-plan.md`
+
+### Spike 1: Reconnect Cascade Measurement (Source-Level Instrumentation)
+Add a `ReconnectTracer` module that logs timestamped events to `window.__reconnectTrace`. Hooks into ws-client.ts, TerminalView.tsx, and App.tsx. Test 4 scenarios in production mode: WS drop, server restart, page refresh, long idle. Measure time-to-recovery per pane.
+
+### Spike 2: Normal Usage Action Storms (Chrome Runtime)
+Use Chrome dispatch interceptor to measure Redux action counts during tab switches, sidebar interactions, terminal output bursts, and 10-minute idle periods. Check for cross-tab sync overhead and localStorage/Redux divergence.
+
+### Spike 3: Terminal Rendering Investigation (Chrome + Code Review)
+Trace why "Recovering terminal output..." appears on fresh terminal creation. Observe xterm.js rendering during heavy output and tab switches. Determine if the rendering layer contributes to the flaky feel.
+
+### Spike 4: Server-Side Performance Audit (Logs + Timing)
+Runs alongside Spike 1. Read server logs during reconnect cascade. Time bootstrap/indexing, API endpoints, and terminal operations. Check for server-side bottlenecks.
+
+### Spike 5: State Consolidation Map (Code Review)
+Catalog all 17 Redux slices and 5 persistence mechanisms. Classify each as server-authoritative, client-local, ephemeral, or derived. Propose simplified state tree.
+
+### Spike 6: Server Snapshot Prototype (After 1-5)
+Write `assembleStateSnapshot()` in ws-handler.ts. Measure size and assembly time. Send after `ready`, log on client. Go/no-go assessment.
+
+### Execution order
+```
+Spike 1 + 4 (together)  → Spike 2 + 3 (parallel) → Spike 5 → Spike 6
+```
+
+---
+
+## Rough Phasing (Contingent on Spike Results)
+
+**Phase 1: Quick wins — Server snapshot on reconnect**
+If Spike 2 confirms feasibility: add a `state.snapshot` message to the handshake. Client uses it to pre-validate terminal IDs before attaching. Eliminates the cascading INVALID_TERMINAL_ID dance. Biggest bang for lowest risk.
+
+**Phase 2: Proactive sync — Revision-gapped events**
+Add change details to `terminals.changed` broadcasts. Client detects missed revisions and requests snapshot catch-up. Closes the "missed broadcast" hole.
+
+**Phase 3: Consolidation — Persistence simplification**
+If Spike 3 confirms the layout mirror is sufficient: make server-stored layout the source of truth. Reduce persistence to one mechanism for UI prefs. Simplify Redux to fewer slices.
+
+**Phase 4: Polish — Invisible reconnect**
+With server snapshot + proactive sync + consolidated persistence, reconnect should be invisible. This phase is about UX polish: no spinners, no flash, no jitter.
+
+---
+
+## Test Baseline (2026-03-26)
+
+- 2816 passing, 9 failing, 11 skipped across 291 test files
+- The 9 failures appear pre-existing on this branch
+- Should investigate before starting implementation work
+
+---
+
+## Open Questions
+
+1. **Server restart recovery:** If the server restarts, all in-memory state (terminals, buffers, metadata) is gone. Should the server persist layouts to disk so it can return them on restart? Or is localStorage-as-fallback acceptable for the restart case?
+2. **Offline/disconnected mode:** If the server is unreachable, localStorage is the only option. Keep as degraded-mode fallback?
+3. **Migration path:** Existing users have localStorage state. Need to handle the transition without losing their setup.
+4. **Cross-device sync:** The `tabs.sync.push` mechanism exists for multi-device. Does server-authoritative layout replace this or work alongside it?
diff --git a/docs/plans/2026-03-26-title-search-subdir-tabs-test-plan.md b/docs/plans/2026-03-26-title-search-subdir-tabs-test-plan.md
new file mode 100644
index 00000000..049a7330
--- /dev/null
+++ b/docs/plans/2026-03-26-title-search-subdir-tabs-test-plan.md
@@ -0,0 +1,160 @@
+# Title Search Subdirectory And Open-Tab Search Behavior Test Plan
+
+## Harness requirements
+
+No new harnesses are required. The implementation plan stays within existing local test infrastructure and does not add paid APIs, external services, or new browser automation dependencies. Extend the existing harnesses with low-complexity fixtures instead of building new ones.
+
+- **Sidebar search flow harness**: `test/e2e/sidebar-search-flow.test.tsx`. Real `Sidebar` + Redux store + mocked `searchSessions` and `fetchSidebarSessionsSnapshot`, with fake timers for debounce and direct DOM actions for typing, tier changes, and clearing. Estimated complexity: low fixture expansion. Depends on test 1.
+- **Sidebar component harness**: `test/unit/client/components/Sidebar.test.tsx`. Rendered `Sidebar` with preloaded store state, tabs/panes fixtures, and scroll geometry helpers for append behavior. Estimated complexity: low fixture expansion. Depends on tests 2-6.
+- **Open-tab App harness**: `test/e2e/open-tab-session-sidebar-visibility.test.tsx`. Full `App` with mocked WebSocket invalidation and API calls. Estimated complexity: none beyond reusing an existing regression gate. Depends on test 7.
+- **Store harnesses**: `test/unit/client/store/sessionsThunks.test.ts` and `test/unit/client/store/sessionsSlice.test.ts`. Redux store with deferred promises for in-flight request timing plus direct reducer action coverage. Estimated complexity: none. Depends on tests 8-10.
+- **Selector harness**: `test/unit/client/store/selectors/sidebarSelectors.test.ts`. Pure selector state fixtures spanning server rows, synthesized fallback rows, tabs, panes, sort modes, and requested/applied search drift. Estimated complexity: low fixture expansion. Depends on tests 11-12.
+- **HTTP router harness**: `test/integration/server/session-directory-router.test.ts`. Express router round-trip via `supertest`. Estimated complexity: low fixture expansion. Depends on test 13.
+- **Service harness**: `test/unit/server/session-directory/service.test.ts`. Direct `querySessionDirectory()` calls with provider and file fixtures. Estimated complexity: low fixture expansion. Depends on test 14.
+- **Shared matcher harness**: `test/unit/shared/session-title-search.test.ts`. New pure unit harness for cross-platform path leaf extraction and metadata precedence. Estimated complexity: low. Depends on test 15.
+
+Minor reconciliation adjustment: in addition to the implementation plan's unit/service coverage, keep the existing `/api/session-directory` router round-trip as an explicit acceptance gate because that is the transport contract the sidebar actually consumes.
+
+## Test plan
+
+1. **Name:** Searching by a subdirectory leaf returns the session, ancestor-only terms do not, and open tabs only appear when they also match
+   **Type:** scenario
+   **Disposition:** extend
+   **Harness:** Sidebar search flow harness
+   **Preconditions:** A rendered sidebar with one indexed session whose `title` does not contain `trycycle`, whose `projectPath` or `cwd` leaf is `trycycle`, plus an open fallback tab whose leaf also matches `trycycle`; a newer non-tab server result is also present so ordering is observable; sidebar sort mode is `activity`.
+   **Actions:** Type `trycycle` into the search input; wait for debounce and mocked title-tier server response; observe the ordered rows. Then replace the query with `code`; wait for the new response.
+   **Expected outcome:** Source of truth: the user transcript, plus the implementation plan Behavior Contract bullets for leaf-directory matching, ancestor rejection, authoritative server rows during applied search, and "no pinning while searching." The `trycycle` query renders the indexed session even though the title lacks `trycycle`; the `code` query does not return that same session unless another metadata field independently contains `code`; the matching fallback open tab is shown only for the matching query; the matching fallback row is not forced above the newer non-tab server row.
+   **Interactions:** Sidebar debounce, `searchSessions()` request payload, Redux search state, selector fallback synthesis, sort policy, and DOM row ordering.
+
+2. **Name:** Applied title search hides unrelated fallback tabs and keeps only locally provable fallback matches
+   **Type:** scenario
+   **Disposition:** extend
+   **Harness:** Sidebar component harness
+   **Preconditions:** Sidebar window already contains committed title-search results from the server. Tabs/panes include one open fallback tab whose `cwd` leaf matches the applied query and one open fallback tab whose metadata does not match. A newer server-backed non-tab row is present.
+   **Actions:** Render the sidebar with the committed search window and inspect the visible rows without issuing a new request.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullets for authoritative server rows during applied search and local fallback injection only when the client can prove a title-tier match. The unrelated fallback tab is absent, the matching fallback tab is present, and the newer server row remains above the fallback row even when the fallback row has `hasTab: true`.
+   **Interactions:** Selector merge of server rows with synthesized fallback rows, applied search gating, activity sort behavior, and row rendering.
+
+3. **Name:** Applied deep search never injects fallback tabs, even when local metadata would have matched
+   **Type:** regression
+   **Disposition:** extend
+   **Harness:** Sidebar component harness
+   **Preconditions:** Sidebar window contains committed `userMessages` or `fullText` results. Tabs/panes include an open fallback tab whose title or `cwd` leaf matches the query text locally.
+   **Actions:** Render the sidebar while the applied deep-search result set is on screen.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullet stating that `userMessages` and `fullText` searches must not inject fallback rows because the client cannot prove deep-file matches. Only server-window rows are visible; the locally matching fallback row is hidden.
+   **Interactions:** Applied search tier handling, selector fallback suppression, and deep-search UI state.
+
+4. **Name:** Starting a replacement search does not locally re-filter the previous committed result set
+   **Type:** regression
+   **Disposition:** extend
+   **Harness:** Sidebar component harness
+   **Preconditions:** Sidebar shows a committed title-search result set for query A. A replacement title-search request for query B is configured to stay in flight after the search input changes.
+   **Actions:** Type query B into the search input and advance past debounce without resolving the new server response.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullets separating requested `query/searchTier` from applied `appliedQuery/appliedSearchTier`, and forbidding local re-filtering of the last committed result set while a replacement query is in flight. The old rows for query A remain visible until query B data commits, even though the input now shows query B and the search-loading chrome is active.
+   **Interactions:** Search input, debounce timer, requested vs applied search state, search-loading indicator, and selector inputs.
+
+5. **Name:** Clearing search keeps browse append pagination disabled until browse data replaces the stale search results
+   **Type:** regression
+   **Disposition:** extend
+   **Harness:** Sidebar component harness
+   **Preconditions:** Sidebar is displaying committed search results with `hasMore: true`. The user clears the search box, triggering a browse reload that has not resolved yet. The list can be scrolled near the bottom.
+   **Actions:** Click the clear-search button; before the browse response resolves, trigger near-bottom scroll or underfilled-viewport backfill logic; then resolve the browse response and repeat the append trigger.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullet that browse pagination must stay disabled while stale search results remain on screen during a search-to-browse transition. No append fetch is issued before browse data lands; once browse results replace the visible search result set, append requests are allowed again.
+   **Interactions:** Clear-search button, fetch-session browse path, requested vs applied search state, append guard, scroll handler, and resize/backfill logic.
+
+6. **Name:** First-load search remains blocking and does not reveal fallback tabs under the spinner
+   **Type:** regression
+   **Disposition:** existing
+   **Harness:** Sidebar component harness
+   **Preconditions:** Sidebar has no committed result set yet, `loadingKind` is `initial`, the applied search is empty because nothing has committed, and tabs/panes contain fallback open sessions.
+   **Actions:** Render the sidebar during the first blocking search load.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullet that blocking first-load behavior stays unchanged. The search-loading UI remains the only visible state; fallback rows do not appear underneath it.
+   **Interactions:** Loading-state hierarchy, fallback synthesis suppression, and empty-result rendering.
+
+7. **Name:** Active-query refresh stays silent while already-committed search results remain on screen
+   **Type:** regression
+   **Disposition:** existing
+   **Harness:** Open-tab App harness
+   **Preconditions:** The full app is mounted with committed search results in the sidebar and a WebSocket-driven refresh is triggered for the active query.
+   **Actions:** Broadcast the refresh/invalidation event and keep the refresh request in flight long enough to observe the UI before it resolves.
+   **Expected outcome:** Source of truth: current user-visible refresh behavior already covered by the existing suite, plus the implementation plan requirement that component logic reason from the result set currently on screen. The existing search result rows remain visible and no extra search chrome appears during the silent refresh. This scenario remains the broad UI regression gate; the store-level commit-authority invariants live in tests 8-9.
+   **Interactions:** App-level WebSocket invalidation, `refreshActiveSessionWindow`, active-query reuse, and sidebar rendering under background work.
+
+8. **Name:** In-flight replacement requests move requested search state immediately but keep applied search state on the visible results until commit
+   **Type:** integration
+   **Disposition:** extend
+   **Harness:** Store harnesses (`sessionsThunks.test.ts`)
+   **Preconditions:** A store with committed sidebar search results for query A. Deferred promises are used for a replacement search for query B and a subsequent search-to-browse transition.
+   **Actions:** Dispatch `fetchSessionWindow()` for query B and inspect state before resolution; resolve query B and inspect state again. Then dispatch `fetchSessionWindow()` for an empty query to return to browse mode and inspect state before and after the browse response resolves.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullets for requested vs applied search state. `query/searchTier` change as soon as loading starts; `appliedQuery/appliedSearchTier` keep describing query A until query B data commits; clearing search starts a browse request but leaves the applied search context intact until browse data commits.
+   **Interactions:** Thunk control flow, reducer commit boundary, abort handling, loading-kind classification, and browse/search request routing.
+
+9. **Name:** Visible refresh commits against the same visible result set even if requested state drifts again, and stale refreshes cannot overwrite a newer committed window
+   **Type:** integration
+   **Disposition:** extend
+   **Harness:** Store harnesses (`sessionsThunks.test.ts`)
+   **Preconditions:** A store with committed sidebar search results for query A plus deferred promises for a visible refresh of A, a replacement request whose requested state moves to browse or query B, and a later replacement or refresh that can commit a newer visible window before the older refresh resolves.
+   **Actions:** Start a visible refresh for query A, then change requested state with a replacement request while leaving A visible; resolve the older visible refresh and inspect state. In a second phase, let a newer commit replace the visible window before the older visible refresh resolves, then resolve the stale refresh.
+   **Expected outcome:** Source of truth: implementation plan Behavior Contract bullets for visible-refresh authority. Requested-state drift alone does not invalidate the visible refresh: if query A is still the visible applied result set and the captured visible-window version/token is unchanged, the refresh may commit without rewriting requested state or cancelling the pending replacement. If a newer commit has already replaced the visible window, the stale refresh is discarded instead of overwriting newer data that happens to share the same query/tier.
+   **Interactions:** Visible-refresh commit guard, applied result-set identity token, replacement sequencing, stale response suppression, and requested-vs-applied drift.
+
+10. **Name:** The reducer only advances applied search fields when new window data commits
+   **Type:** unit
+   **Disposition:** extend
+   **Harness:** Store harnesses (`sessionsSlice.test.ts`)
+   **Preconditions:** A `SessionWindowState` with committed search results and populated applied search fields.
+   **Actions:** Dispatch `setSessionWindowLoading()` with a new requested query and tier; inspect state. Then dispatch `setSessionWindowData()` for the replacement result set; inspect state again.
+   **Expected outcome:** Source of truth: implementation plan Strategy Gate and Behavior Contract sections describing `setSessionWindowLoading()` as a requested-state update and `setSessionWindowData()` as the commit point for the visible result set. Loading updates only `query/searchTier`; data commit updates both requested and applied fields to the newly committed values.
+   **Interactions:** Pure reducer boundary for the visible-result-set contract.
+
+11. **Name:** Applied title search uses the shared metadata rules for fallback gating and rejects ancestor-only matches
+    **Type:** invariant
+    **Disposition:** extend
+    **Harness:** Selector harness
+    **Preconditions:** Selector state contains server-backed items, synthesized fallback rows, and requested search state that intentionally differs from applied search state. Fixtures cover an indexed row whose `projectPath` leaf is `trycycle`, a fallback row whose `cwd` leaf is `trycycle`, and rows whose ancestor path segment is `code`.
+    **Actions:** Run `makeSelectSortedSessionItems()` with an applied title query of `trycycle`, then with an applied title query of `code`, then with an applied deep-search tier while keeping the same fallback fixtures.
+    **Expected outcome:** Source of truth: user transcript plus implementation plan Behavior Contract bullets on leaf-only directory matching, project-path precedence for indexed rows, fallback `cwd` matching, and no fallback injection for deep tiers. Indexed rows match on their leaf subtitle metadata, cwd-only fallback rows match on their leaf, ancestor-only `code` does not match, and deep tiers drop fallback rows entirely.
+    **Interactions:** Shared metadata matcher contract, selector state inputs, fallback-row synthesis, and applied tier handling.
+
+12. **Name:** Applied search disables tab pinning in `activity` and `recency-pinned` modes while preserving archived-last ordering and ignoring requested-state drift
+    **Type:** invariant
+    **Disposition:** extend
+    **Harness:** Selector harness
+    **Preconditions:** Selector state includes a newer non-tab server row, an older matching fallback row with `hasTab: true`, archived and non-archived rows, and requested search state that differs from applied search state.
+    **Actions:** Run the selector under `activity` sort, then under `recency-pinned`, first with an applied search active and then with no applied search.
+    **Expected outcome:** Source of truth: implementation plan Behavior Contract bullets that search disables `hasTab` pinning regardless of sort mode, archived-last remains intact, and selector search behavior must come from applied fields rather than requested ones. During applied search, the older fallback row is not promoted above the newer non-tab row in either sort mode, archived rows remain last, and requested-state drift does not re-enable pinning or re-filter the visible set early. Without applied search, the existing pinning behavior stays unchanged.
+    **Interactions:** Sort comparator behavior, archived grouping, requested vs applied state, and synthesized fallback rows.
+
+13. **Name:** `/api/session-directory` title-tier search matches the subdirectory leaf through the real HTTP contract and keeps the existing schema
+    **Type:** integration
+    **Disposition:** extend
+    **Harness:** HTTP router harness
+    **Preconditions:** The Express router is mounted with indexed sessions whose `projectPath` or deeper `cwd` leaf is `trycycle`, while titles omit that term. A sibling path containing ancestor segment `code` is also present to prove rejection. Providers are omitted for title-tier requests where possible.
+    **Actions:** Issue `GET /api/session-directory?priority=visible&query=trycycle`, then `GET /api/session-directory?priority=visible&query=code`, and inspect the returned JSON.
+    **Expected outcome:** Source of truth: user transcript, implementation plan Behavior Contract, and the unchanged `SessionDirectoryPage` schema in `shared/read-models.ts`. The `trycycle` query returns the matching session through the real endpoint; the `code` query does not return it on ancestor-only path text; the response shape stays in the current read-model contract, including existing `matchedIn` semantics and no new transport fields.
+    **Interactions:** Router query parsing, service invocation, read-model schema validation, and title-tier provider-free search path.
+
+14. **Name:** Service-level title-tier search keeps ordering, snippet behavior, provider-free execution, and the existing low-risk performance guard after directory matching is added
+    **Type:** integration
+    **Disposition:** extend
+    **Harness:** Service harness
+    **Preconditions:** Direct `querySessionDirectory()` fixtures cover title matches, summary or first-user-message matches, project-path leaf matches, deeper `cwd` values for indexed sessions, archived sessions, and a large corpus for the performance guard.
+    **Actions:** Query the service with title-tier searches that hit each metadata source; query with an ancestor-only term; query without providers; run the existing many-session timing guard.
+    **Expected outcome:** Source of truth: implementation plan Behavior Contract and Strategy Gate, especially the rules to keep title-tier metadata search provider-free and keep snippet extraction in the service. Directory matches preserve the canonical ordering and archived handling, metadata snippets stay bounded and query-focused, title-tier search still works without file providers, ancestor-only queries do not match, and the generous timing guard still catches catastrophic regressions without turning this task into performance work.
+    **Interactions:** Projection ordering, server-side snippet extraction, provider lookup bypass for title tier, and metadata-only search cost.
+
+15. **Name:** Shared title-tier metadata matching extracts leaf directory names cross-platform and honors the required precedence
+    **Type:** unit
+    **Disposition:** new
+    **Harness:** Shared matcher harness
+    **Preconditions:** Pure metadata fixtures cover POSIX and Windows paths, trailing separators, indexed sessions with both `projectPath` and deeper `cwd`, fallback rows with only `cwd`, summary and first-user-message metadata, and an ancestor-only query.
+    **Actions:** Call `getLeafDirectoryName()` and `matchTitleTierMetadata()` across those fixtures.
+    **Expected outcome:** Source of truth: implementation plan Behavior Contract and Task 1 test requirements. Leaf extraction returns `trycycle` from both POSIX and Windows paths, trailing separators are ignored, precedence is `title` then `projectPath` leaf then distinct `cwd` leaf then `summary` then `firstUserMessage`, indexed sessions prefer the `projectPath` leaf, cwd-only fallback metadata still matches, and ancestor-only `code` does not match.
+    **Interactions:** Pure shared metadata-matching seam used by both the server search path and client fallback gating.
+
+## Coverage summary
+
+- **Covered action space:** typing into the sidebar search input; changing the search tier dropdown; clicking the clear-search button; triggering near-bottom scroll and underfilled-viewport append logic; rendering committed search results while replacement work is in flight; active-query refresh via app-level invalidation; visible-refresh commit ordering under requested-state drift; selector merging of server rows with synthesized fallback rows from tabs/panes; HTTP `GET /api/session-directory` title-tier queries; service-level metadata search; shared path-leaf extraction.
+- **Covered unchanged behaviors kept as regression gates:** first-load blocking search hides fallback tabs; active-query background refresh remains silent; title-tier search remains provider-free; archived-last ordering remains intact; existing read-model transport shape does not change.
+- **Explicitly excluded:** deep file-content matching correctness beyond fallback suppression, click-to-open session behavior, and terminal-directory/busy-indicator behavior. Those surfaces are unchanged by this task and already have dedicated coverage elsewhere.
+- **Risk carried by the exclusions:** if unrelated deep-search file scanning, session-open behavior, or terminal-state rendering regress at the same time, this plan will detect only the parts that overlap with applied search state and fallback gating, not every independent failure in those adjacent features.
diff --git a/docs/plans/2026-03-26-title-search-subdir-tabs.md b/docs/plans/2026-03-26-title-search-subdir-tabs.md
new file mode 100644
index 00000000..17395a30
--- /dev/null
+++ b/docs/plans/2026-03-26-title-search-subdir-tabs.md
@@ -0,0 +1,269 @@
+# Sidebar Title Search Subdirectory And Open-Tab Search Behavior Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use trycycle-executing to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Finish the already-started sidebar search feature by preserving the shipped leaf-directory title matching and match-aware open-tab visibility, while fixing the remaining refresh drift bug so direct and queued refreshes revalidate only the visible result set without mutating requested search state or aborting a pending browse/search replacement.
+
+**Architecture:** Keep the existing user-facing search behavior already present on this branch: title-tier search matches the leaf subdirectory, fallback open tabs only appear when they locally prove a title-tier match, and applied search disables tab pinning. The remaining work is architectural: make replacement commits and visible-refresh commits distinct reducer contracts, add an explicit monotonic visible result-set token to sidebar window state, and make both `refreshActiveSessionWindow()` and queued invalidations refresh by visible-result identity instead of routing back through the generic replacement path.
+
+**Tech Stack:** React 18, Redux Toolkit, TypeScript, shared utilities, Vitest, Testing Library
+
+---
+
+## Behavior Contract
+
+- Title-tier search must continue to match `title`, then the project-path leaf subtitle, then a distinct `cwd` leaf, then `summary` and `firstUserMessage`.
+- Only leaf directory names are searchable for the new metadata behavior. `/home/user/code/trycycle` matches `trycycle`; it does not match `code` unless some other searchable field independently matches `code`.
+- During an applied search, open-tab fallback rows appear only when local metadata proves a title-tier match. Deep-search tiers remain server-authoritative and must not inject fallback rows.
+- During an applied search, `hasTab` must not pin rows above other matches. Archived-last behavior still applies.
+- `query/searchTier` represent the next requested sidebar state. `appliedQuery/appliedSearchTier` represent the result set currently displayed.
+- Clearing the search box starts a browse replacement immediately, but the visible list stays on the old applied search result set until browse data commits.
+- Visible refreshes are not replacement requests. They revalidate whatever result set is currently on screen and must not:
+  - rewrite requested `query/searchTier`
+  - abort or replace the controller for a pending replacement request
+  - discard a pending replacement request when refresh data commits
+- Visible-refresh commit eligibility must be based on visible result-set identity only: `appliedQuery`, `appliedSearchTier`, and a monotonic committed result-set token captured when the refresh starts.
+- If a newer commit replaces the visible result set before an older refresh resolves, the stale refresh must be dropped.
+
+## File Structure
+
+- Modify: `src/store/sessionsSlice.ts`
+  Responsibility: model committed result-set identity explicitly and give replacement commits and visible-refresh commits different reducer entry points.
+- Modify: `src/store/sessionsThunks.ts`
+  Responsibility: keep replacement requests abort-driven and make direct/queued refreshes use a separate visible-refresh flow keyed to committed visible identity.
+- Modify: `test/unit/client/store/sessionsSlice.test.ts`
+  Responsibility: lock the reducer contract for requested state, applied state, result-set identity, and loading preservation.
+- Modify: `test/unit/client/store/sessionsThunks.test.ts`
+  Responsibility: lock the refresh-vs-replacement thunk contract, including the direct-refresh drift bug that is still open.
+- Modify: `test/e2e/open-tab-session-sidebar-visibility.test.tsx`
+  Responsibility: prove the real sidebar keeps visible search results stable during drift, keeps refresh silent, and still lets the pending browse replacement commit afterward.
+
+## Strategy Gate
+
+- Do not rework the already-landed leaf-directory matcher or selector fallback policy unless a regression test proves a real bug. The branch already contains `shared/session-title-search.ts`, server search wiring, and applied-search fallback gating; the remaining blocker is the refresh pipeline.
+- Do not keep using ambiguous reducer flags as the primary abstraction. `preserveRequestedSearch` / `preserveLoading` are acceptable only as compatibility shims during the refactor; the final reducer API must make replacement commits and visible-refresh commits obviously different operations.
+- Do not route `refreshActiveSessionWindow()` through `fetchSessionWindow()`. That path owns requested state and the surface abort controller, which is exactly what broke the search-to-browse drift contract.
+- Do not key refresh safety to requested `query/searchTier`. Requested state is future intent and is allowed to drift while the old result set remains visible.
+- Do not use wall-clock timing as the conceptual identity of a visible result set. Add an explicit monotonic token on the sidebar window state so tests can assert stale-refresh dropping without depending on `Date.now()`.
+- Do not touch `Sidebar.tsx`, `sidebarSelectors.ts`, shared matcher code, or server search code unless the focused regression runs in Task 2 show a real failure there.
+
+### Task 1: Make Sidebar Window Commits Explicit In The Reducer
+
+**Files:**
+- Modify: `src/store/sessionsSlice.ts`
+- Modify: `test/unit/client/store/sessionsSlice.test.ts`
+
+- [ ] **Step 1: Write the failing reducer tests for explicit commit types**
+
+In `test/unit/client/store/sessionsSlice.test.ts`, replace the flag-oriented reducer coverage with tests that prove these exact contracts:
+
+- replacement loading updates requested `query/searchTier` immediately, preserves `appliedQuery/appliedSearchTier`, and does not bump the committed result-set token
+- replacement commit updates `projects`, requested state, applied state, clears loading, and increments the committed result-set token
+- visible-refresh commit updates `projects` and the committed result-set token, preserves requested `query/searchTier`, preserves an in-flight replacement loading state when requested, and keeps `appliedQuery/appliedSearchTier` on the refreshed visible context
+- replacement failure preserves the last applied context and the current committed result-set token
+
+Make the tests name the new state field directly. Use `resultVersion` unless an equivalent explicit monotonic name is already present after refactor.
+
+- [ ] **Step 2: Run the targeted reducer tests to verify they fail**
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task1 explicit sidebar reducer commits" \
+  npm run test:vitest -- \
+  test/unit/client/store/sessionsSlice.test.ts
+```
+
+Expected: FAIL because the reducer still relies on one generic data commit shape plus preservation flags, and it does not yet expose an explicit committed result-set token.
+
+- [ ] **Step 3: Refactor the reducer around explicit replacement and visible-refresh commits**
+
+In `src/store/sessionsSlice.ts`:
+
+- add an explicit monotonic committed result-set token on `SessionWindowState`
+
+```ts
+resultVersion?: number
+```
+
+- keep `setSessionWindowLoading()` as the replacement-start action that writes requested `query/searchTier`
+- replace the generic “one payload fits both cases” data commit shape with two explicit reducer actions:
+
+```ts
+commitSessionWindowReplacement(...)
+commitSessionWindowVisibleRefresh(...)
+```
+
+- make `commitSessionWindowReplacement(...)`:
+  - write `projects`, paging metadata, and error/loading cleanup
+  - advance both requested and applied `query/searchTier`
+  - increment `resultVersion`
+- make `commitSessionWindowVisibleRefresh(...)`:
+  - write `projects`, paging metadata, and clear any refresh error
+  - preserve requested `query/searchTier`
+  - keep `appliedQuery/appliedSearchTier` on the refreshed visible context
+  - preserve replacement loading state when instructed by the thunk
+  - increment `resultVersion`
+- keep top-level active-surface syncing behavior unchanged
+
+- [ ] **Step 4: Re-run the targeted reducer tests to verify they pass**
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task1 explicit sidebar reducer commits" \
+  npm run test:vitest -- \
+  test/unit/client/store/sessionsSlice.test.ts
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Refactor and verify the reducer seam**
+
+After the tests are green:
+
+- remove leftover flag-only branches that no longer express the primary contract
+- keep reducer names and payload shapes self-describing enough that a future thunk bug cannot “accidentally” use the wrong commit path
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task1 reducer seam verification" \
+  npm run test:vitest -- \
+  test/unit/client/store/sessionsSlice.test.ts
+```
+
+Expected: PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+git add \
+  src/store/sessionsSlice.ts \
+  test/unit/client/store/sessionsSlice.test.ts
+git commit -m "refactor: split sidebar replacement and refresh commits"
+```
+
+### Task 2: Rebuild Sidebar Refresh Flow Around Visible Result-Set Identity
+
+**Files:**
+- Modify: `src/store/sessionsThunks.ts`
+- Modify: `test/unit/client/store/sessionsThunks.test.ts`
+- Modify: `test/e2e/open-tab-session-sidebar-visibility.test.tsx`
+
+- [ ] **Step 1: Write the failing thunk and end-to-end regressions**
+
+In `test/unit/client/store/sessionsThunks.test.ts`, add or tighten coverage that proves:
+
+- `refreshActiveSessionWindow()` during search-to-browse drift does **not** call the replacement path contract:
+  - the already-started browse `fetchSidebarSessionsSnapshot()` stays the only in-flight browse replacement
+  - its `AbortSignal` is still not aborted after the direct refresh completes
+  - requested `query` stays cleared while `appliedQuery` stays on the visible search result set
+  - the pending browse replacement still resolves and commits after the direct refresh
+- `queueActiveSessionWindowRefresh()` obeys the same invariants during the same drift
+- a visible refresh captures `{ appliedQuery, appliedSearchTier, resultVersion }` at start and still commits when requested state drifts again but the visible result set has not changed
+- a stale visible refresh is dropped when a newer replacement or refresh commit increments `resultVersion` before the old refresh resolves
+- direct refresh without drift still uses the visible applied context and remains background/silent rather than “new search” chrome
+
+In `test/e2e/open-tab-session-sidebar-visibility.test.tsx`, strengthen the existing direct-refresh scenario so it asserts:
+
+- clearing the search box starts one browse replacement request and leaves the old search results visible
+- dispatching `refreshActiveSessionWindow()` during that drift keeps the search result rows visible and keeps the search indicator silent
+- after the direct refresh resolves, the browse replacement still commits and the applied search state finally clears
+
+- [ ] **Step 2: Run the targeted thunk and e2e tests to verify they fail**
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task2 visible refresh identity contract" \
+  npm run test:vitest -- \
+  test/unit/client/store/sessionsThunks.test.ts \
+  test/e2e/open-tab-session-sidebar-visibility.test.tsx
+```
+
+Expected: FAIL because `refreshActiveSessionWindow()` still routes through `fetchSessionWindow()`, which rewrites requested state and aborts the pending replacement controller.
+
+- [ ] **Step 3: Refactor the thunks to separate replacement requests from visible refreshes**
+
+In `src/store/sessionsThunks.ts`:
+
+- keep `fetchSessionWindow()` as the explicit browse/search replacement path and the only path that owns the surface abort controller in `controllers`
+- introduce an explicit visible-result identity helper:
+
+```ts
+type VisibleResultIdentity = {
+  query: string
+  searchTier: SearchOptions['tier']
+  resultVersion: number
+}
+```
+
+- capture visible refresh identity from `appliedQuery`, `appliedSearchTier`, and the committed `resultVersion`
+- make the visible-refresh helper:
+  - fetch using the visible applied context
+  - commit through `commitSessionWindowVisibleRefresh(...)`
+  - decide stale-vs-valid using only the captured visible identity
+  - never rewrite requested `query/searchTier`
+  - never abort or replace the controller for a pending replacement request
+- update `refreshActiveSessionWindow()` to call the visible-refresh helper directly instead of dispatching `fetchSessionWindow()`
+- keep `queueActiveSessionWindowRefresh()` queue-based, but make queued invalidations use the same visible-refresh helper whenever they are revalidating what is already on screen
+- preserve current two-phase deep search behavior and browse pagination behavior for replacement requests
+
+- [ ] **Step 4: Re-run the targeted thunk and e2e tests to verify they pass**
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task2 visible refresh identity contract" \
+  npm run test:vitest -- \
+  test/unit/client/store/sessionsThunks.test.ts \
+  test/e2e/open-tab-session-sidebar-visibility.test.tsx
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Refactor and run the broader regression suite**
+
+After the targeted tests are green:
+
+- remove any remaining helper path that infers visible refresh safety from requested `query/searchTier`
+- confirm the refactor did not regress the already-landed user-facing feature behavior in shared matcher, server search, selector gating, and sidebar rendering
+
+Run:
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+FRESHELL_TEST_SUMMARY="task2 title-search subdir regressions" \
+  npm run test:vitest -- \
+  test/unit/shared/session-title-search.test.ts \
+  test/unit/server/session-directory/service.test.ts \
+  test/integration/server/session-directory-router.test.ts \
+  test/unit/client/store/selectors/sidebarSelectors.test.ts \
+  test/unit/client/components/Sidebar.test.tsx \
+  test/e2e/sidebar-search-flow.test.tsx \
+  test/e2e/open-tab-session-sidebar-visibility.test.tsx \
+  test/unit/client/store/sessionsSlice.test.ts \
+  test/unit/client/store/sessionsThunks.test.ts
+npm run lint
+FRESHELL_TEST_SUMMARY="final verification for title-search subdir tabs" npm run check
+```
+
+Expected: all PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+cd /home/user/code/freshell/.worktrees/trycycle-title-search-subdir-tabs
+git add \
+  src/store/sessionsThunks.ts \
+  test/unit/client/store/sessionsThunks.test.ts \
+  test/e2e/open-tab-session-sidebar-visibility.test.tsx
+git commit -m "fix: refresh sidebar results without mutating requested search"
+```
diff --git a/docs/plans/2026-03-27-inline-progress-session-repair-test-plan.md b/docs/plans/2026-03-27-inline-progress-session-repair-test-plan.md
new file mode 100644
index 00000000..0aa7344f
--- /dev/null
+++ b/docs/plans/2026-03-27-inline-progress-session-repair-test-plan.md
@@ -0,0 +1,326 @@
+# Inline Stop-Hook Progress Session Repair -- Test Plan
+
+## Harness Requirements
+
+### No new harnesses needed
+
+All tests use existing infrastructure:
+
+1. **Unit harness (scanner):** `vitest.server.config.ts` with `test/unit/server/session-scanner.test.ts`. Uses `createSessionScanner()` directly against fixture JSONL files. Temp directory for repair tests (copy fixture, mutate, assert). Already established with `beforeEach`/`afterEach` lifecycle.
+
+2. **Unit harness (queue):** `vitest.server.config.ts` with `test/unit/server/session-queue.test.ts`. Uses mock scanners (`vi.fn()`) and real `SessionCache` instances in temp directories. Already established with priority, event, and waitFor patterns.
+
+3. **Integration harness (ws-handler):** `vitest.server.config.ts` with `test/server/ws-terminal-create-session-repair.test.ts`. Spins up a real HTTP server with `WsHandler`, injects `FakeSessionRepairService` and `FakeRegistry`, connects real WebSocket clients. Already established with helper functions (`waitForReady`, `waitForCreated`, `closeWebSocket`).
+
+**Note:** The implementation plan's test run commands reference `--config vitest.config.ts` for scanner and queue tests. This is incorrect -- those tests live under `test/unit/server/` which is excluded from the default config and included only in `vitest.server.config.ts`. The correct invocation is:
+```bash
+npm run test:vitest -- --config vitest.server.config.ts test/unit/server/session-scanner.test.ts
+npm run test:vitest -- --config vitest.server.config.ts test/unit/server/session-queue.test.ts
+```
+This does not affect scope or cost -- it is a correction to the plan's commands.
+
+### Fixture files (new, required)
+
+Two JSONL fixture files must be created before tests can run:
+
+- `test/fixtures/sessions/inline-stop-hook-progress.jsonl` -- healthy session with the problematic active-chain shape
+- `test/fixtures/sessions/sibling-stop-hook-progress.jsonl` -- healthy session with the same records but stop_hook_summary correctly parented to assistant (control)
+
+These are specified in the implementation plan with exact content.
+
+---
+
+## Test Plan
+
+### 1. Scan classifies inline stop-hook progress on the active chain as a resume issue
+
+- **Name:** Scanning a session with inline stop-hook progress on the active chain flags `resumeIssue: 'inline_stop_hook_progress'`
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** `inline-stop-hook-progress.jsonl` fixture exists with the chain shape `user -> assistant -> progress(hook_progress/Stop) -> stop_hook_summary -> turn_duration`.
+- **Actions:** Call `scanner.scan(fixturePath)`.
+- **Expected outcome:**
+  - `result.status === 'healthy'` (source: design decision -- "the session is healthy (no orphans)")
+  - `result.orphanCount === 0` (source: fixture has no orphans -- all parentUuids resolve)
+  - `result.resumeIssue === 'inline_stop_hook_progress'` (source: plan Chunk 1, Step 3 test specification)
+- **Interactions:** `parseMessage()` must now extract `subtype`, `toolUseID`, `dataType`, `dataHookEvent` from JSONL. `detectInlineStopHookProgress()` must walk the active leaf chain.
+
+### 2. Scan does not flag sibling stop-hook progress (control)
+
+- **Name:** Scanning a session where stop_hook_summary is correctly parented to assistant (not through progress) reports no resume issue
+- **Type:** differential
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** `sibling-stop-hook-progress.jsonl` fixture exists with `stop_hook_summary.parentUuid` pointing to the assistant, not the progress record.
+- **Actions:** Call `scanner.scan(fixturePath)`.
+- **Expected outcome:**
+  - `result.status === 'healthy'` (source: fixture is healthy)
+  - `result.orphanCount === 0`
+  - `result.resumeIssue === undefined` (source: plan Chunk 1, Step 3 -- "does not flag sibling stop-hook progress that is off the active chain")
+- **Interactions:** Same chain-walking logic; validates the specificity of the detection (does not false-positive on the repaired shape).
+
+### 3. Scan does not flag resume issue for files without stop-hook progress
+
+- **Name:** Scanning a normal healthy session without any stop-hook records reports no resume issue
+- **Type:** regression
+- **Disposition:** extend (extends existing healthy scan test)
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** `healthy.jsonl` fixture exists (already present).
+- **Actions:** Call `scanner.scan(fixturePath)`.
+- **Expected outcome:**
+  - `result.status === 'healthy'`
+  - `result.resumeIssue === undefined` (source: plan Chunk 1, Step 3 -- "does not flag resume issue for files without stop-hook progress")
+- **Interactions:** Ensures the new detection code does not regress existing healthy file classification.
+
+### 4. Repair rewrites stop_hook_summary parentUuid when includeResumeIssues is true
+
+- **Name:** Repairing an inline-progress session with `includeResumeIssues: true` reparents the stop_hook_summary to the assistant
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Call `scanner.repair(testFile, { includeResumeIssues: true })`.
+- **Expected outcome:**
+  - `result.status === 'repaired'` (source: plan Chunk 2, Step 1)
+  - `result.resumeIssuesFixed === 1`
+  - `result.orphansFixed === 0`
+  - Post-repair scan: `scanAfter.status === 'healthy'` and `scanAfter.resumeIssue === undefined`
+- **Interactions:** File I/O (write modified JSONL), backup creation, `detectInlineStopHookProgress` inside repair path.
+
+### 5. Default repair (no options) does not rewrite inline-progress sessions
+
+- **Name:** Calling repair without `includeResumeIssues` on an inline-progress session leaves the file unchanged
+- **Type:** boundary
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Call `scanner.repair(testFile)` (no options).
+- **Expected outcome:**
+  - `result.status === 'already_healthy'` (source: plan Chunk 2, Step 1 -- "does not rewrite inline-progress sessions during default repair")
+  - `result.resumeIssuesFixed === 0`
+  - `result.orphansFixed === 0`
+  - Post-repair scan: `scanAfter.resumeIssue === 'inline_stop_hook_progress'` (issue still present)
+- **Interactions:** Validates the gating -- disk/background scans call `repair()` without options and must not rewrite these files.
+
+### 6. Repair is idempotent for inline stop-hook progress
+
+- **Name:** Calling repair with `includeResumeIssues` twice: first repairs, second is already_healthy
+- **Type:** invariant
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Call `scanner.repair(testFile, { includeResumeIssues: true })` twice.
+- **Expected outcome:**
+  - First call: `status === 'repaired'`, `resumeIssuesFixed === 1`
+  - Second call: `status === 'already_healthy'`, `resumeIssuesFixed === 0`
+  - (Source: plan Chunk 2, Step 1 -- "repair is idempotent for inline stop-hook progress")
+- **Interactions:** Validates that after repair the detection function returns undefined, preventing re-repair.
+
+### 7. Repair preserves all fields except stop_hook_summary.parentUuid
+
+- **Name:** After inline progress repair, only the stop_hook_summary line's parentUuid changes; all other data is preserved
+- **Type:** invariant
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Read file before repair, call `scanner.repair(testFile, { includeResumeIssues: true })`, read file after repair.
+- **Expected outcome:**
+  - Same number of lines
+  - Every line: `uuid` and `type` preserved
+  - Line with `uuid === 's-004'` (stop_hook_summary): `parentUuid` changed from `'p-003'` to `'a-002'`
+  - All other lines: `parentUuid` unchanged
+  - (Source: plan Chunk 2, Step 1 -- "preserves all fields except stop_hook_summary.parentUuid during inline progress repair")
+- **Interactions:** Validates the surgical nature of the rewrite -- no collateral damage to JSONL content.
+
+### 8. Repair creates backup before inline progress repair
+
+- **Name:** Inline progress repair creates a timestamped backup of the original file
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Read original content, call `scanner.repair(testFile, { includeResumeIssues: true })`.
+- **Expected outcome:**
+  - `result.backupPath` is defined and matches `/\.backup-\d+$/`
+  - Backup file content equals original content
+  - (Source: plan Chunk 2, Step 1 -- "creates backup before inline progress repair")
+- **Interactions:** File system: backup file creation alongside the session file.
+
+### 9. No backup created when inline progress repair is not enabled
+
+- **Name:** Default repair on an inline-progress session does not create a backup
+- **Type:** boundary
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Call `scanner.repair(testFile)` (no options).
+- **Expected outcome:**
+  - `result.status === 'already_healthy'`
+  - `result.backupPath === undefined`
+  - (Source: plan Chunk 2, Step 1 -- "does not create backup when inline progress repair is not enabled")
+- **Interactions:** Validates that the backup is gated on actual repair, not just detection.
+
+### 10. Progress record remains as side leaf after repair
+
+- **Name:** After inline progress repair, the progress record is still in the file, parented to the assistant
+- **Type:** invariant
+- **Disposition:** new
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Copy of `inline-stop-hook-progress.jsonl` in temp directory.
+- **Actions:** Call `scanner.repair(testFile, { includeResumeIssues: true })`, read file, find progress line.
+- **Expected outcome:**
+  - Progress line with `uuid === 'p-003'` exists
+  - `progressObj.parentUuid === 'a-002'` (still parented to assistant)
+  - `progressObj.type === 'progress'`
+  - (Source: plan Chunk 2, Step 1 -- "leaves progress record in file as side leaf after repair")
+- **Interactions:** The repair only reparents stop_hook_summary; it does not remove or modify the progress record.
+
+### 11. Queue does not repair healthy sessions with resume issues during disk scans
+
+- **Name:** A disk-priority scan of a session with inline-progress resume issue caches the result but does not trigger repair
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (queue), `vitest.server.config.ts`
+- **Preconditions:** Mock scanner returning a scan result with `resumeIssue: 'inline_stop_hook_progress'` and `status: 'healthy'`.
+- **Actions:** Enqueue at `priority: 'disk'`, start, `waitFor()`.
+- **Expected outcome:**
+  - `result.status === 'healthy'`
+  - `result.resumeIssue === 'inline_stop_hook_progress'`
+  - `scanner.repair` not called
+  - (Source: plan Chunk 3, Step 1 -- "does not repair healthy sessions with resume issues during disk scans")
+- **Interactions:** Queue processing path, cache set, event emission. Validates that disk/background scans are read-only for this issue.
+
+### 12. Queue repairs healthy sessions with resume issues during active scans
+
+- **Name:** An active-priority scan of a session with inline-progress resume issue triggers repair and returns the clean result
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (queue), `vitest.server.config.ts`
+- **Preconditions:** Mock scanner: first `scan()` returns resume-issue result, `repair()` returns repaired result, second `scan()` returns clean result.
+- **Actions:** Enqueue at `priority: 'active'`, start, `waitFor()`.
+- **Expected outcome:**
+  - `result.status === 'healthy'`
+  - `result.resumeIssue === undefined`
+  - `scanner.repair` called with `{ includeResumeIssues: true }`
+  - (Source: plan Chunk 3, Step 1 -- "repairs healthy sessions with resume issues during active scans")
+- **Interactions:** Queue scan-repair-rescan cycle, cache update, event emission.
+
+### 13. Queue bypasses cache for active priority when cached result has resume issue
+
+- **Name:** When a cached result has a resume issue and a new active-priority item arrives, the queue bypasses the cache and triggers scan+repair
+- **Type:** scenario
+- **Disposition:** new
+- **Harness:** Unit (queue), `vitest.server.config.ts`
+- **Preconditions:** Cache seeded with a result that has `resumeIssue: 'inline_stop_hook_progress'`. Mock scanner: first `scan()` returns resume-issue result, `repair()` returns repaired, second `scan()` returns clean.
+- **Actions:** Enqueue at `priority: 'active'`, start, `waitFor()`.
+- **Expected outcome:**
+  - `result.resumeIssue === undefined`
+  - `scanner.repair` called with `{ includeResumeIssues: true }`
+  - (Source: plan Chunk 3, Step 1 -- "bypasses cache for active priority when cached result has resume issue")
+- **Interactions:** Cache read, cache bypass logic, queue processing path.
+
+### 14. Queue uses cached resume-issue result for disk priority without repair
+
+- **Name:** When a cached result has a resume issue and a disk-priority item arrives, the queue uses the cached result without scanning or repairing
+- **Type:** boundary
+- **Disposition:** new
+- **Harness:** Unit (queue), `vitest.server.config.ts`
+- **Preconditions:** Cache seeded with a result that has `resumeIssue: 'inline_stop_hook_progress'`.
+- **Actions:** Enqueue at `priority: 'disk'`, start, `waitFor()`.
+- **Expected outcome:**
+  - `result.resumeIssue === 'inline_stop_hook_progress'`
+  - `scanner.scan` not called
+  - `scanner.repair` not called
+  - (Source: plan Chunk 3, Step 1 -- "uses cached resume-issue result for disk priority without repair")
+- **Interactions:** Cache read, priority-based decision logic.
+
+### 15. Integration: terminal.create proceeds with resume after inline-progress repair
+
+- **Name:** When FakeSessionRepairService has a cached result with resume issue, `terminal.create` still calls `waitForSession` and proceeds with resume using the repaired result
+- **Type:** integration
+- **Disposition:** new
+- **Harness:** Integration (ws-handler), `vitest.server.config.ts`
+- **Preconditions:** `FakeSessionRepairService.result` set to a healthy result with `resumeIssue: 'inline_stop_hook_progress'`. `FakeSessionRepairService.waitForSessionResult` set to a clean healthy result (no resume issue).
+- **Actions:** Connect WebSocket, handshake, send `terminal.create` with `resumeSessionId`.
+- **Expected outcome:**
+  - `created.effectiveResumeSessionId === VALID_SESSION_ID` (resume proceeds, not dropped)
+  - `sessionRepairService.waitForSessionCalls` contains the session ID (repair path was invoked)
+  - (Source: plan Chunk 4, Step 1 -- ws-handler sees `status: 'healthy'` (not missing) from getResult, falls through to waitForSession, which returns the clean result)
+- **Interactions:** ws-handler -> FakeSessionRepairService.getResult() -> FakeSessionRepairService.waitForSession() -> FakeRegistry.create(). Validates the full terminal.create flow does not drop the resume for sessions that have `status: 'healthy'` with a resume issue.
+
+### 16. Existing orphan repair behavior is unchanged
+
+- **Name:** Existing orphan repair tests continue to pass with the new `resumeIssuesFixed` field and `options` parameter
+- **Type:** regression
+- **Disposition:** existing
+- **Harness:** Unit (scanner), `vitest.server.config.ts`
+- **Preconditions:** Existing corrupted fixture files.
+- **Actions:** Run all existing `describe('repair()')` tests.
+- **Expected outcome:**
+  - All existing repair tests pass without modification (source: plan Chunk 1, Step 5 -- "Update the existing `repair()` to include `resumeIssuesFixed: 0` in all return paths")
+  - `result.resumeIssuesFixed === 0` for all orphan-only repairs (implicitly -- existing tests don't assert this, but the implementation must not break them)
+- **Interactions:** All existing repair code paths with the new optional parameter.
+
+### 17. Existing queue processing behavior is unchanged
+
+- **Name:** Existing queue tests continue to pass with the new cache-bypass and repair-gating logic
+- **Type:** regression
+- **Disposition:** existing
+- **Harness:** Unit (queue), `vitest.server.config.ts`
+- **Preconditions:** Existing queue test setup.
+- **Actions:** Run all existing `describe('start() and processing')` and `describe('waitFor()')` tests.
+- **Expected outcome:**
+  - All existing tests pass (source: plan design -- changes are additive and the new logic only triggers for results with `resumeIssue`)
+- **Interactions:** Queue processing for healthy, corrupted, cached, and error scenarios.
+
+### 18. Existing integration tests for terminal.create remain unchanged
+
+- **Name:** Existing ws-terminal-create-session-repair integration tests continue to pass
+- **Type:** regression
+- **Disposition:** existing
+- **Harness:** Integration (ws-handler), `vitest.server.config.ts`
+- **Preconditions:** Existing test setup with `FakeSessionRepairService` and `FakeRegistry`.
+- **Actions:** Run all existing tests in `describe('terminal.create session repair wait')`.
+- **Expected outcome:**
+  - All 11 existing tests pass. The `FakeSessionRepairService` returns results without `resumeIssue` by default (undefined), so the ws-handler's behavior is unchanged.
+- **Interactions:** Full ws-handler flow including repair wait, missing-session handling, duplicate prevention, disconnect handling.
+
+### 19. TypeScript compilation passes
+
+- **Name:** All type changes compile cleanly with no errors
+- **Type:** invariant
+- **Disposition:** extend (existing typecheck)
+- **Harness:** `npm run typecheck`
+- **Preconditions:** All source changes applied.
+- **Actions:** Run `npm run typecheck`.
+- **Expected outcome:**
+  - Zero errors (source: plan Verification section -- "The type changes are backward-compatible")
+  - The optional `resumeIssue` on `SessionScanResult`, `resumeIssuesFixed` on `SessionRepairResult`, and `options` on `repair()` do not break any existing consumers.
+- **Interactions:** All files importing from `server/session-scanner/types.ts`.
+
+---
+
+## Coverage Summary
+
+### Covered areas
+
+| Area | Tests | Coverage quality |
+|---|---|---|
+| Scan classification (inline-progress detection) | #1, #2, #3 | Full: positive match, negative control, absence check |
+| Repair writer (pointer rewrite) | #4, #5, #6, #7, #8, #9, #10 | Full: enabled/disabled, idempotency, field preservation, backup, side-leaf preservation |
+| Queue gating (priority-based repair decision) | #11, #12, #13, #14 | Full: disk-no-repair, active-repair, cache-bypass, cache-reuse |
+| Service + ws-handler integration | #15 | Validates the end-to-end flow for the problem statement |
+| Regression (orphan repair) | #16 | Existing tests run; no modification needed |
+| Regression (queue processing) | #17 | Existing tests run; no modification needed |
+| Regression (ws integration) | #18 | Existing tests run; no modification needed |
+| Type safety | #19 | Full typecheck |
+
+### Explicitly excluded
+
+| Area | Reason | Risk |
+|---|---|---|
+| Real `SessionRepairService.waitForSession()` unit test | The service class requires glob, fs, cache, queue, and history-repair infrastructure. The implementation plan wires the change into `waitForSession()` at three code paths (existing result, legacy result, cache result). The queue-level tests (#12, #13) prove the active-priority repair flow, and the integration test (#15) proves the ws-handler correctly calls `waitForSession`. The service-internal logic (checking `resumeIssue` and calling `clearProcessed + enqueue + waitFor`) is small enough that the combination of queue-level and integration tests provides adequate coverage. | Low. If the service fails to bypass stale results, the integration test would fail (it expects `waitForSessionCalls` to contain the session ID). A future unit-testable service refactor could add direct coverage. |
+| Multi-turn inline-progress (more than one progress record) | The implementation detects exactly one pattern: the active leaf shape ending in `stop_hook_summary -> progress -> assistant`. Multiple progress records would have different leaf shapes. | Low. The detection is pattern-matched, not count-based. Additional progress records that are not on the active leaf path are ignored by design. |
+| Concurrent file writes during repair | The plan explicitly defers repair to the `active` path (triggered by `terminal.create`) to avoid race conditions with running Claude processes. | Medium. If a Claude process writes to the JSONL while repair is in progress, the file could be corrupted. The backup mitigates data loss, but the repair could produce an incorrect result. This is an accepted risk per the design decision "deferring the repair to the active resume path is both safer and more efficient." |
+| Frontend/UI changes | No frontend changes in this plan. | None. |
diff --git a/docs/plans/2026-03-27-inline-progress-session-repair.md b/docs/plans/2026-03-27-inline-progress-session-repair.md
new file mode 100644
index 00000000..db2fa306
--- /dev/null
+++ b/docs/plans/2026-03-27-inline-progress-session-repair.md
@@ -0,0 +1,1237 @@
+# Inline Stop-Hook Progress Session Repair Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use trycycle-executing to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Detect and repair Claude session JSONL files where an inline Stop-hook `progress` record on the active chain causes `claude --resume` to repaint as blank, without affecting disk-scan read-only behavior for otherwise healthy sessions.
+
+**Architecture:** Extend the existing single-pass JSONL scan to classify a specific active-chain leaf shape (`assistant -> progress -> stop_hook_summary [-> turn_duration]`) as a resume issue. Keep `status: 'healthy'` for these sessions (they have no orphans). Add a `resumeIssue` field to `SessionScanResult` that the queue and service use to gate repair. Only the `active`-priority path (triggered by `terminal.create` with a `resumeSessionId`) is allowed to rewrite the file. The rewrite patches exactly one field: `stop_hook_summary.parentUuid` is changed from the `progress` UUID to the `assistant` UUID. The `progress` record stays in the file as a side leaf. After repair, the session is rescanned and cached before the resume proceeds.
+
+**Tech Stack:** TypeScript, NodeNext/ESM, Claude JSONL session files, Vitest unit tests, Vitest server integration tests.
+
+---
+
+## Design Decisions and Rationale
+
+### Why `resumeIssue` rather than a new `status` value
+
+The existing `status` field (`healthy | corrupted | missing | unreadable`) drives eager repair for corrupted files at all priorities. Adding a new status like `resume_issue` would require auditing every consumer of `status` to decide whether to treat it like healthy or corrupted. Instead, the `resumeIssue` field is orthogonal: the session is healthy (no orphans), but has a known resume-time problem. This keeps the existing repair pipeline unchanged and adds the new behavior as a clean extension.
+
+### Why repair only on the `active` path
+
+Disk and background scans process hundreds of sessions at startup. Rewriting files during startup adds I/O load and creates race conditions with running Claude processes that might be writing to the same JSONL files. The inline-progress issue only manifests when `--resume` is actually invoked, so deferring the repair to the `active` resume path is both safer and more efficient.
+
+### Why extend `ParsedMessage` minimally
+
+The scanner's `ParsedMessage` currently extracts only `uuid`, `parentUuid`, `type`, and `lineNumber`. The inline-progress detection needs four additional fields from the raw JSON: `subtype` (for stop_hook_summary), `toolUseID` (for matching stop_hook_summary to progress), `data.type` (to confirm hook_progress), and `data.hookEvent` (to confirm Stop). These are extracted only when present, keeping the parse cost minimal.
+
+### Why the `SessionScanner` interface gains `options` on `repair()`
+
+The existing `repair()` signature has no options parameter. Adding `SessionRepairOptions` with `includeResumeIssues?: boolean` lets the queue signal whether this repair call should also fix resume issues. Orphan repair remains the default (no options needed). The interface change is backward-compatible: existing callers without options get the same behavior.
+
+### Why not add `resumeIssuesFixed` to `SessionRepairResult`
+
+The existing `SessionRepairResult` already has `orphansFixed: number` and `status: 'repaired' | 'already_healthy' | 'failed'`. Adding `resumeIssuesFixed: number` to it lets callers distinguish orphan repairs from resume-issue repairs, which is useful for logging and testing. The existing `status` values remain sufficient: `repaired` means something was fixed, `already_healthy` means nothing needed fixing.
+
+---
+
+## File Structure Map
+
+- Modify: `server/session-scanner/types.ts`
+  - Add `SessionResumeIssue` type, `resumeIssue` field to `SessionScanResult`, `resumeIssuesFixed` field to `SessionRepairResult`, `SessionRepairOptions` interface, update `SessionScanner.repair()` signature.
+- Modify: `server/session-scanner/scanner.ts`
+  - Extend `parseMessage()` to extract four additional fields. Add `detectInlineStopHookProgress()` function. Wire classification into `scan()` and targeted pointer rewrite into `repair()`.
+- Modify: `server/session-scanner/queue.ts`
+  - Add cache-bypass logic for `resumeIssue` results at `active` priority. Pass `includeResumeIssues` to `repair()` when appropriate. Add `clearProcessed(sessionId)` method to allow the service to remove stale processed entries before re-enqueueing.
+- Modify: `server/session-scanner/service.ts`
+  - Prevent `waitForSession()` from returning cached results with `resumeIssue` directly; call `clearProcessed` then re-enqueue at `active` priority.
+- Create: `test/fixtures/sessions/inline-stop-hook-progress.jsonl`
+  - Healthy session whose active chain has the exact inline-progress shape: `user -> assistant -> progress(hook_progress/Stop) -> stop_hook_summary -> turn_duration`.
+- Create: `test/fixtures/sessions/sibling-stop-hook-progress.jsonl`
+  - Control fixture: same hook records present but the stop_hook_summary is parented to the assistant (not the progress), so no resume issue.
+- Modify: `test/unit/server/session-scanner.test.ts`
+  - Add scan classification and repair tests for inline-progress detection.
+- Modify: `test/unit/server/session-queue.test.ts`
+  - Add queue-level tests proving disk scans only classify while active priority triggers repair.
+- Modify: `test/server/ws-terminal-create-session-repair.test.ts`
+  - Add integration test proving `terminal.create` blocks for inline-progress repair on the active path.
+
+---
+
+## Chunk 1: Scanner Classification
+
+### Task 1: Create fixture files and extend scanner to classify inline stop-hook progress
+
+**Files:**
+- Create: `test/fixtures/sessions/inline-stop-hook-progress.jsonl`
+- Create: `test/fixtures/sessions/sibling-stop-hook-progress.jsonl`
+- Modify: `server/session-scanner/types.ts`
+- Modify: `server/session-scanner/scanner.ts`
+- Modify: `test/unit/server/session-scanner.test.ts`
+
+- [ ] **Step 1: Create the inline-stop-hook-progress fixture**
+
+This fixture must be **healthy** (no orphans) but have the active chain shape that causes blank resume. The key shape is:
+
+```
+user -> assistant -> progress(type=progress, data.type=hook_progress, data.hookEvent=Stop) -> stop_hook_summary(type=system, subtype=stop_hook_summary, matching toolUseID) -> turn_duration(type=system, subtype=turn_duration)
+```
+
+Create `test/fixtures/sessions/inline-stop-hook-progress.jsonl`:
+
+```jsonl
+{"type":"user","message":"Help me with a task","uuid":"u-001","parentUuid":null,"timestamp":"2026-01-30T10:00:00.000Z"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Sure, I can help."}]},"uuid":"a-002","parentUuid":"u-001","timestamp":"2026-01-30T10:00:01.000Z"}
+{"type":"progress","data":{"type":"hook_progress","hookEvent":"Stop","hookName":"Stop","command":"echo done"},"toolUseID":"tool-001","parentToolUseID":"tool-001","uuid":"p-003","parentUuid":"a-002","timestamp":"2026-01-30T10:00:02.000Z"}
+{"type":"system","subtype":"stop_hook_summary","hookCount":1,"hookInfos":[{"command":"echo done"}],"hookErrors":[],"preventedContinuation":false,"stopReason":"","hasOutput":false,"level":"suggestion","uuid":"s-004","parentUuid":"p-003","toolUseID":"tool-001","timestamp":"2026-01-30T10:00:03.000Z"}
+{"type":"system","subtype":"turn_duration","durationMs":2500,"uuid":"td-005","parentUuid":"s-004","timestamp":"2026-01-30T10:00:04.000Z"}
+```
+
+This has 5 messages, all with valid parent chains (no orphans), so the existing scanner will report `status: 'healthy'`. But the active chain suffix is `assistant -> progress -> stop_hook_summary -> turn_duration`, which is exactly the shape that causes blank resume.
+
+- [ ] **Step 2: Create the sibling-stop-hook-progress control fixture**
+
+This fixture has the same hook records present, but the `stop_hook_summary` is parented directly to the `assistant` (bypassing the `progress`). This is the "already repaired" or "non-problematic" shape. The `progress` record exists as a side leaf, not inline on the active chain.
+
+Create `test/fixtures/sessions/sibling-stop-hook-progress.jsonl`:
+
+```jsonl
+{"type":"user","message":"Help me with a task","uuid":"u-001","parentUuid":null,"timestamp":"2026-01-30T10:00:00.000Z"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Sure, I can help."}]},"uuid":"a-002","parentUuid":"u-001","timestamp":"2026-01-30T10:00:01.000Z"}
+{"type":"progress","data":{"type":"hook_progress","hookEvent":"Stop","hookName":"Stop","command":"echo done"},"toolUseID":"tool-001","parentToolUseID":"tool-001","uuid":"p-003","parentUuid":"a-002","timestamp":"2026-01-30T10:00:02.000Z"}
+{"type":"system","subtype":"stop_hook_summary","hookCount":1,"hookInfos":[{"command":"echo done"}],"hookErrors":[],"preventedContinuation":false,"stopReason":"","hasOutput":false,"level":"suggestion","uuid":"s-004","parentUuid":"a-002","toolUseID":"tool-001","timestamp":"2026-01-30T10:00:03.000Z"}
+{"type":"system","subtype":"turn_duration","durationMs":2500,"uuid":"td-005","parentUuid":"s-004","timestamp":"2026-01-30T10:00:04.000Z"}
+```
+
+Note: the only difference is `s-004.parentUuid` is `"a-002"` (the assistant) instead of `"p-003"` (the progress).
+
+- [ ] **Step 3: Write the failing scan classification tests**
+
+Add to `test/unit/server/session-scanner.test.ts` inside the `describe('scan()')` block:
+
+```typescript
+it('flags inline stop-hook progress on the active chain as a resume issue', async () => {
+  const result = await scanner.scan(path.join(FIXTURES_DIR, 'inline-stop-hook-progress.jsonl'))
+
+  expect(result.status).toBe('healthy')
+  expect(result.orphanCount).toBe(0)
+  expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+})
+
+it('does not flag sibling stop-hook progress that is off the active chain', async () => {
+  const result = await scanner.scan(path.join(FIXTURES_DIR, 'sibling-stop-hook-progress.jsonl'))
+
+  expect(result.status).toBe('healthy')
+  expect(result.orphanCount).toBe(0)
+  expect(result.resumeIssue).toBeUndefined()
+})
+
+it('does not flag resume issue for files without stop-hook progress', async () => {
+  const result = await scanner.scan(path.join(FIXTURES_DIR, 'healthy.jsonl'))
+
+  expect(result.status).toBe('healthy')
+  expect(result.resumeIssue).toBeUndefined()
+})
+```
+
+- [ ] **Step 4: Run the scanner tests to verify the new assertions fail**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: FAIL because `SessionScanResult` does not yet have a `resumeIssue` property and the scanner does not classify the inline-progress leaf shape.
+
+- [ ] **Step 5: Extend types and implement bounded leaf-shape detection**
+
+In `server/session-scanner/types.ts`:
+
+1. Add the resume issue type:
+
+```typescript
+/**
+ * Known resume issues that don't constitute corruption but prevent
+ * successful `--resume` in Claude CLI.
+ */
+export type SessionResumeIssue = 'inline_stop_hook_progress'
+```
+
+2. Add `resumeIssue` to `SessionScanResult`:
+
+```typescript
+export interface SessionScanResult {
+  // ... existing fields ...
+  /** Resume issue detected on the active chain, if any */
+  resumeIssue?: SessionResumeIssue
+}
+```
+
+3. Add `SessionRepairOptions`:
+
+```typescript
+/**
+ * Options for session repair.
+ */
+export interface SessionRepairOptions {
+  /** Also fix resume issues (not just orphans). Default: false. */
+  includeResumeIssues?: boolean
+}
+```
+
+4. Add `resumeIssuesFixed` to `SessionRepairResult`:
+
+```typescript
+export interface SessionRepairResult {
+  // ... existing fields ...
+  /** Number of resume issues that were fixed */
+  resumeIssuesFixed: number
+}
+```
+
+5. Update the `SessionScanner` interface's `repair()` method:
+
+```typescript
+export interface SessionScanner {
+  scan(filePath: string): Promise<SessionScanResult>
+  repair(filePath: string, options?: SessionRepairOptions): Promise<SessionRepairResult>
+  scanBatch(filePaths: string[]): Promise<SessionScanResult[]>
+}
+```
+
+In `server/session-scanner/scanner.ts`:
+
+1. Extend `ParsedMessage` fields extracted in `parseMessage()`. Add `subtype`, `toolUseID`, and two fields from `data`:
+
+```typescript
+function parseMessage(line: string, lineNumber: number): ParsedMessage | null {
+  if (!line.trim()) return null
+
+  try {
+    const obj = JSON.parse(line)
+    if (!obj.uuid) return null
+
+    return {
+      uuid: obj.uuid,
+      parentUuid: obj.parentUuid,
+      type: obj.type,
+      lineNumber,
+      subtype: obj.subtype,
+      toolUseID: obj.toolUseID,
+      dataType: obj.data?.type,
+      dataHookEvent: obj.data?.hookEvent,
+    }
+  } catch {
+    return null
+  }
+}
+```
+
+2. Update the `ParsedMessage` interface in `types.ts` to include these optional fields:
+
+```typescript
+export interface ParsedMessage {
+  uuid: string
+  parentUuid?: string
+  type?: string
+  lineNumber: number
+  /** System message subtype (e.g. 'stop_hook_summary', 'turn_duration') */
+  subtype?: string
+  /** Tool use ID for progress/hook records */
+  toolUseID?: string
+  /** data.type for progress records (e.g. 'hook_progress') */
+  dataType?: string
+  /** data.hookEvent for progress records (e.g. 'Stop') */
+  dataHookEvent?: string
+}
+```
+
+3. Add the detection function in `scanner.ts`:
+
+```typescript
+/**
+ * Detect the inline stop-hook progress chain shape on the active leaf.
+ *
+ * The problematic shape is (from leaf toward root):
+ *   turn_duration? -> stop_hook_summary -> progress(hook_progress/Stop) -> assistant
+ *
+ * Where stop_hook_summary.parentUuid === progress.uuid
+ *   and stop_hook_summary.toolUseID === progress.toolUseID
+ *   and progress.dataType === 'hook_progress'
+ *   and progress.dataHookEvent === 'Stop'
+ *   and the progress is parented to an assistant message.
+ *
+ * Returns the matched nodes if found, or undefined.
+ */
+interface InlineProgressMatch {
+  stopSummary: ParsedMessage
+  progress: ParsedMessage
+  assistant: ParsedMessage
+}
+
+function detectInlineStopHookProgress(
+  lastMessage: ParsedMessage | undefined,
+  uuidToMessage: Map<string, ParsedMessage>,
+): InlineProgressMatch | undefined {
+  if (!lastMessage) return undefined
+
+  // The leaf may be turn_duration (skip it) or stop_hook_summary directly
+  let candidate = lastMessage
+  if (candidate.type === 'system' && candidate.subtype === 'turn_duration' && candidate.parentUuid) {
+    const parent = uuidToMessage.get(candidate.parentUuid)
+    if (parent) candidate = parent
+  }
+
+  // Candidate should be stop_hook_summary
+  if (candidate.type !== 'system' || candidate.subtype !== 'stop_hook_summary') return undefined
+  const stopSummary = candidate
+
+  // Parent of stop_hook_summary should be the progress record
+  if (!stopSummary.parentUuid) return undefined
+  const progress = uuidToMessage.get(stopSummary.parentUuid)
+  if (!progress) return undefined
+
+  // Validate progress record
+  if (progress.type !== 'progress') return undefined
+  if (progress.dataType !== 'hook_progress') return undefined
+  if (progress.dataHookEvent !== 'Stop') return undefined
+
+  // Validate toolUseID match
+  if (!stopSummary.toolUseID || stopSummary.toolUseID !== progress.toolUseID) return undefined
+
+  // Parent of progress should be an assistant message
+  if (!progress.parentUuid) return undefined
+  const assistant = uuidToMessage.get(progress.parentUuid)
+  if (!assistant) return undefined
+  if (assistant.type !== 'assistant') return undefined
+
+  return { stopSummary, progress, assistant }
+}
+```
+
+4. Wire classification into `scan()`. After calculating orphans and chain depth, add:
+
+```typescript
+// Detect resume issue on active chain (bounded: at most 3 parent hops from leaf)
+const lastMessage = messages.length > 0 ? messages[messages.length - 1] : undefined
+const resumeMatch = detectInlineStopHookProgress(lastMessage, uuidToMessage)
+
+return {
+  sessionId,
+  filePath,
+  status: orphans.length > 0 ? 'corrupted' : 'healthy',
+  chainDepth,
+  orphanCount: orphans.length,
+  fileSize: stat.size,
+  messageCount: messages.length,
+  resumeIssue: resumeMatch ? 'inline_stop_hook_progress' : undefined,
+}
+```
+
+5. Update the existing `repair()` to include `resumeIssuesFixed: 0` in all return paths. The `repair()` signature gains the optional `options` parameter but the inline-progress repair logic is added in Task 2.
+
+- [ ] **Step 6: Run the scanner tests to verify they pass**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: All tests PASS, including the three new classification tests and all existing tests. Existing tests should continue to pass unchanged because `resumeIssue` defaults to `undefined` for healthy files without the inline-progress shape, and `resumeIssuesFixed` is always 0 (repair not yet implemented).
+
+- [ ] **Step 7: Refactor and verify**
+
+Review the code for clarity. Ensure:
+- `detectInlineStopHookProgress` is well-named and documented
+- `ParsedMessage` field names are consistent with the raw JSON field names
+- No unnecessary fields are being extracted
+- The detection function handles all edge cases (missing fields, missing parents)
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: All PASS.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add \
+  server/session-scanner/types.ts \
+  server/session-scanner/scanner.ts \
+  test/fixtures/sessions/inline-stop-hook-progress.jsonl \
+  test/fixtures/sessions/sibling-stop-hook-progress.jsonl \
+  test/unit/server/session-scanner.test.ts
+git commit -m "feat: classify inline stop-hook progress resume issue in scanner"
+```
+
+---
+
+## Chunk 2: Targeted Repair Writer
+
+### Task 2: Implement the pointer rewrite for classified resume issues
+
+**Files:**
+- Modify: `server/session-scanner/scanner.ts`
+- Modify: `test/unit/server/session-scanner.test.ts`
+
+- [ ] **Step 1: Write the failing repair tests**
+
+Add to `test/unit/server/session-scanner.test.ts` inside the `describe('repair()')` block:
+
+```typescript
+it('rewrites stop_hook_summary parentUuid to bypass inline stop-hook progress when enabled', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+  const result = await scanner.repair(testFile, { includeResumeIssues: true })
+
+  expect(result.status).toBe('repaired')
+  expect(result.resumeIssuesFixed).toBe(1)
+  expect(result.orphansFixed).toBe(0)
+
+  // Verify the file is now clean (no resume issue)
+  const scanAfter = await scanner.scan(testFile)
+  expect(scanAfter.status).toBe('healthy')
+  expect(scanAfter.resumeIssue).toBeUndefined()
+})
+
+it('does not rewrite inline-progress sessions during default repair (no options)', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+  const result = await scanner.repair(testFile)
+
+  expect(result.status).toBe('already_healthy')
+  expect(result.resumeIssuesFixed).toBe(0)
+  expect(result.orphansFixed).toBe(0)
+
+  // Resume issue should still be present
+  const scanAfter = await scanner.scan(testFile)
+  expect(scanAfter.resumeIssue).toBe('inline_stop_hook_progress')
+})
+
+it('repair is idempotent for inline stop-hook progress', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+  const result1 = await scanner.repair(testFile, { includeResumeIssues: true })
+  expect(result1.status).toBe('repaired')
+  expect(result1.resumeIssuesFixed).toBe(1)
+
+  const result2 = await scanner.repair(testFile, { includeResumeIssues: true })
+  expect(result2.status).toBe('already_healthy')
+  expect(result2.resumeIssuesFixed).toBe(0)
+})
+
+it('preserves all fields except stop_hook_summary.parentUuid during inline progress repair', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+  const linesBefore = (await fs.readFile(testFile, 'utf8')).split('\n').filter(Boolean)
+
+  await scanner.repair(testFile, { includeResumeIssues: true })
+
+  const linesAfter = (await fs.readFile(testFile, 'utf8')).split('\n').filter(Boolean)
+  expect(linesAfter.length).toBe(linesBefore.length)
+
+  for (let i = 0; i < linesBefore.length; i++) {
+    const before = JSON.parse(linesBefore[i])
+    const after = JSON.parse(linesAfter[i])
+
+    // uuid, type, and all non-parentUuid fields must be preserved
+    expect(after.uuid).toBe(before.uuid)
+    expect(after.type).toBe(before.type)
+
+    // Only the stop_hook_summary line should have a changed parentUuid
+    if (before.uuid === 's-004') {
+      // stop_hook_summary was re-parented from progress (p-003) to assistant (a-002)
+      expect(before.parentUuid).toBe('p-003')
+      expect(after.parentUuid).toBe('a-002')
+    } else {
+      expect(after.parentUuid).toBe(before.parentUuid)
+    }
+  }
+})
+
+it('creates backup before inline progress repair', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+  const originalContent = await fs.readFile(testFile, 'utf8')
+
+  const result = await scanner.repair(testFile, { includeResumeIssues: true })
+
+  expect(result.backupPath).toBeDefined()
+  expect(result.backupPath).toMatch(/\.backup-\d+$/)
+
+  const backupContent = await fs.readFile(result.backupPath!, 'utf8')
+  expect(backupContent).toBe(originalContent)
+})
+
+it('does not create backup when inline progress repair is not enabled', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+  const result = await scanner.repair(testFile)
+
+  expect(result.status).toBe('already_healthy')
+  expect(result.backupPath).toBeUndefined()
+})
+
+it('leaves progress record in file as side leaf after repair', async () => {
+  const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+  await scanner.repair(testFile, { includeResumeIssues: true })
+
+  const content = await fs.readFile(testFile, 'utf8')
+  const lines = content.split('\n').filter(Boolean)
+  const progressLine = lines.find(l => {
+    const obj = JSON.parse(l)
+    return obj.uuid === 'p-003'
+  })
+  expect(progressLine).toBeDefined()
+  // Progress record should still be parented to assistant
+  const progressObj = JSON.parse(progressLine!)
+  expect(progressObj.parentUuid).toBe('a-002')
+  expect(progressObj.type).toBe('progress')
+})
+```
+
+- [ ] **Step 2: Run the repair tests to verify they fail**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: FAIL because `repair()` does not yet accept options or fix resume issues.
+
+- [ ] **Step 3: Implement the pointer rewrite in `repair()`**
+
+In `server/session-scanner/scanner.ts`, modify the `repair()` function:
+
+1. Add the `options` parameter:
+
+```typescript
+async function repair(filePath: string, options?: SessionRepairOptions): Promise<SessionRepairResult> {
+```
+
+2. **Critical:** Update the inline `ParsedMessage` construction inside `repair()` to include the new fields. The existing code (around line 182) builds ParsedMessage with only `uuid`, `parentUuid`, `type`, `lineNumber`. The `detectInlineStopHookProgress` function needs `subtype`, `toolUseID`, `dataType`, and `dataHookEvent`. Update the inline construction:
+
+```typescript
+const msg: ParsedMessage = {
+  uuid: obj.uuid,
+  parentUuid: obj.parentUuid,
+  type: obj.type,
+  lineNumber: i,
+  subtype: obj.subtype,
+  toolUseID: obj.toolUseID,
+  dataType: obj.data?.type,
+  dataHookEvent: obj.data?.hookEvent,
+}
+```
+
+Without this change, `detectInlineStopHookProgress` will always return `undefined` inside `repair()` because the ParsedMessage objects will lack the fields it checks. Note: `repair()` does NOT call `parseMessage()` -- it builds ParsedMessage inline because it also needs `lineToObj`. Both code paths must extract the same fields.
+
+3. After building `messages`, `uuidToMessage`, and `lineToObj` but before the orphan check, detect the inline-progress match when enabled:
+
+```typescript
+const inlineMatch = options?.includeResumeIssues
+  ? detectInlineStopHookProgress(
+      messages.length > 0 ? messages[messages.length - 1] : undefined,
+      uuidToMessage,
+    )
+  : undefined
+```
+
+4. Update the early-return condition to check both orphans and inline match:
+
+```typescript
+if (orphans.length === 0 && !inlineMatch) {
+  const chainDepth = calculateChainDepth(messages, uuidToMessage)
+  return {
+    sessionId,
+    status: 'already_healthy',
+    orphansFixed: 0,
+    resumeIssuesFixed: 0,
+    newChainDepth: chainDepth,
+  }
+}
+```
+
+5. After the orphan-fix loop, add the inline-progress fix:
+
+```typescript
+let resumeIssuesFixed = 0
+if (inlineMatch) {
+  const obj = lineToObj.get(inlineMatch.stopSummary.lineNumber)
+  if (obj) {
+    obj.parentUuid = inlineMatch.assistant.uuid
+    fixedLines[inlineMatch.stopSummary.lineNumber] = JSON.stringify(obj)
+    resumeIssuesFixed = 1
+  }
+}
+```
+
+6. Include `resumeIssuesFixed` in all return paths of the function.
+
+7. Ensure backup creation still happens before the write -- the existing backup code already runs before writing `fixedLines`, which is correct. The backup condition should be: create backup if `orphans.length > 0 || inlineMatch`.
+
+Important implementation note: the existing backup code is already positioned before `fixedLines` is written. If the orphan section was the only thing creating backups, verify that the backup creation also fires for inline-only repairs. The cleanest approach is: move the backup creation to after all fixes are determined but before writing, and gate it on `orphans.length > 0 || resumeIssuesFixed > 0`.
+
+- [ ] **Step 4: Run the scanner tests to verify they pass**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: All PASS, including all new repair tests and all existing orphan repair tests.
+
+- [ ] **Step 5: Refactor and verify**
+
+Check that:
+- The repair function handles the case where both orphans and inline-progress issues exist in the same file (both should be fixed in one pass)
+- The `resumeIssuesFixed` count is accurate
+- Backup creation is correct for all combinations
+- The function signature update is reflected in the import from `types.ts`
+
+Run the full scanner suite:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add \
+  server/session-scanner/scanner.ts \
+  test/unit/server/session-scanner.test.ts
+git commit -m "feat: implement inline stop-hook progress pointer rewrite"
+```
+
+---
+
+## Chunk 3: Queue Gating
+
+### Task 3: Make the queue trigger inline-progress repair only for active priority
+
+**Files:**
+- Modify: `server/session-scanner/queue.ts`
+- Modify: `test/unit/server/session-queue.test.ts`
+
+- [ ] **Step 1: Write the failing queue tests**
+
+Add to `test/unit/server/session-queue.test.ts` inside the `describe('start() and processing')` block:
+
+```typescript
+it('does not repair healthy sessions with resume issues during disk scans', async () => {
+  const scanResult: SessionScanResult = {
+    sessionId: 'resume-issue',
+    filePath: '/tmp/resume-issue.jsonl',
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  const scanner = {
+    scan: vi.fn().mockResolvedValue(scanResult),
+    repair: vi.fn(),
+    scanBatch: vi.fn(),
+  }
+
+  const localCache = new SessionCache(path.join(tempDir, 'cache-disk.json'))
+  const localQueue = new SessionRepairQueue(scanner as any, localCache)
+
+  localQueue.enqueue([
+    { sessionId: 'resume-issue', filePath: '/tmp/resume-issue.jsonl', priority: 'disk' },
+  ])
+
+  localQueue.start()
+  const result = await localQueue.waitFor('resume-issue', 5000)
+
+  expect(result.status).toBe('healthy')
+  expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+  expect(scanner.repair).not.toHaveBeenCalled()
+
+  await localQueue.stop()
+})
+
+it('repairs healthy sessions with resume issues during active scans', async () => {
+  const scanResult: SessionScanResult = {
+    sessionId: 'resume-issue',
+    filePath: '/tmp/resume-issue.jsonl',
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  const repairedScanResult: SessionScanResult = {
+    ...scanResult,
+    resumeIssue: undefined,
+  }
+
+  const scanner = {
+    scan: vi.fn()
+      .mockResolvedValueOnce(scanResult)
+      .mockResolvedValueOnce(repairedScanResult),
+    repair: vi.fn().mockResolvedValue({
+      sessionId: 'resume-issue',
+      status: 'repaired',
+      orphansFixed: 0,
+      resumeIssuesFixed: 1,
+      newChainDepth: 5,
+    }),
+    scanBatch: vi.fn(),
+  }
+
+  const localCache = new SessionCache(path.join(tempDir, 'cache-active.json'))
+  const localQueue = new SessionRepairQueue(scanner as any, localCache)
+
+  localQueue.enqueue([
+    { sessionId: 'resume-issue', filePath: '/tmp/resume-issue.jsonl', priority: 'active' },
+  ])
+
+  localQueue.start()
+  const result = await localQueue.waitFor('resume-issue', 5000)
+
+  expect(result.status).toBe('healthy')
+  expect(result.resumeIssue).toBeUndefined()
+  expect(scanner.repair).toHaveBeenCalledWith('/tmp/resume-issue.jsonl', { includeResumeIssues: true })
+
+  await localQueue.stop()
+})
+
+it('bypasses cache for active priority when cached result has resume issue', async () => {
+  const cachedResult: SessionScanResult = {
+    sessionId: 'cached-resume-issue',
+    filePath: path.join(tempDir, 'cached-resume.jsonl'),
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  // Create a real file so cache.set stat() works
+  await fs.writeFile(path.join(tempDir, 'cached-resume.jsonl'), '{}')
+
+  const repairedScanResult: SessionScanResult = {
+    ...cachedResult,
+    resumeIssue: undefined,
+  }
+
+  const scanner = {
+    scan: vi.fn()
+      .mockResolvedValueOnce(cachedResult)
+      .mockResolvedValueOnce(repairedScanResult),
+    repair: vi.fn().mockResolvedValue({
+      sessionId: 'cached-resume-issue',
+      status: 'repaired',
+      orphansFixed: 0,
+      resumeIssuesFixed: 1,
+      newChainDepth: 5,
+    }),
+    scanBatch: vi.fn(),
+  }
+
+  const localCache = new SessionCache(path.join(tempDir, 'cache-bypass.json'))
+  // Seed cache with the resume-issue result
+  await localCache.set(path.join(tempDir, 'cached-resume.jsonl'), cachedResult)
+
+  const localQueue = new SessionRepairQueue(scanner as any, localCache)
+  localQueue.enqueue([
+    { sessionId: 'cached-resume-issue', filePath: path.join(tempDir, 'cached-resume.jsonl'), priority: 'active' },
+  ])
+
+  localQueue.start()
+  const result = await localQueue.waitFor('cached-resume-issue', 5000)
+
+  expect(result.resumeIssue).toBeUndefined()
+  expect(scanner.repair).toHaveBeenCalledWith(
+    path.join(tempDir, 'cached-resume.jsonl'),
+    { includeResumeIssues: true },
+  )
+
+  await localQueue.stop()
+})
+
+it('uses cached resume-issue result for disk priority without repair', async () => {
+  const cachedResult: SessionScanResult = {
+    sessionId: 'cached-disk-resume',
+    filePath: path.join(tempDir, 'cached-disk.jsonl'),
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  await fs.writeFile(path.join(tempDir, 'cached-disk.jsonl'), '{}')
+
+  const scanner = {
+    scan: vi.fn(),
+    repair: vi.fn(),
+    scanBatch: vi.fn(),
+  }
+
+  const localCache = new SessionCache(path.join(tempDir, 'cache-disk-reuse.json'))
+  await localCache.set(path.join(tempDir, 'cached-disk.jsonl'), cachedResult)
+
+  const localQueue = new SessionRepairQueue(scanner as any, localCache)
+  localQueue.enqueue([
+    { sessionId: 'cached-disk-resume', filePath: path.join(tempDir, 'cached-disk.jsonl'), priority: 'disk' },
+  ])
+
+  localQueue.start()
+  const result = await localQueue.waitFor('cached-disk-resume', 5000)
+
+  expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+  expect(scanner.scan).not.toHaveBeenCalled()
+  expect(scanner.repair).not.toHaveBeenCalled()
+
+  await localQueue.stop()
+})
+```
+
+- [ ] **Step 2: Run the queue tests to verify they fail**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-queue.test.ts
+```
+
+Expected: FAIL because the queue does not distinguish resume issues from healthy results and does not pass `includeResumeIssues` to `repair()`.
+
+- [ ] **Step 3: Implement active-only repair promotion in the queue**
+
+In `server/session-scanner/queue.ts`, import `SessionRepairOptions` from `types.js`.
+
+Then modify the `processNext()` method. The key changes are:
+
+1. **Cache bypass for active priority with resume issues.** After the cache check, if the cached result has a `resumeIssue` and the item's priority is `active`, do NOT use the cached result -- fall through to scan and repair.
+
+Replace the cache-hit block:
+
+```typescript
+// Check cache first
+const cached = await this.cache.get(item.filePath, {
+  allowStaleMs: item.priority === 'active' ? ACTIVE_CACHE_GRACE_MS : undefined,
+})
+if (cached) {
+  // For active priority: bypass cache if result has a resume issue that needs repair
+  if (item.priority === 'active' && cached.resumeIssue) {
+    // Fall through to scan/repair path below
+  } else {
+    const normalized = cached.sessionId === item.sessionId
+      ? cached
+      : { ...cached, sessionId: item.sessionId }
+    await this.postScan?.(normalized)
+    this.setProcessed(item.sessionId, normalized)
+    this.emit('scanned', normalized)
+    this.resolveWaiting(item.sessionId, normalized)
+    return
+  }
+}
+```
+
+2. **Repair for active priority with resume issues.** After the scan, in addition to repairing `corrupted` sessions, also repair `healthy` sessions with resume issues when the priority is `active`:
+
+Replace the repair decision block:
+
+```typescript
+// Repair if corrupted, or if active priority and has resume issue
+const needsRepair = normalizedScan.status === 'corrupted'
+  || (item.priority === 'active' && !!normalizedScan.resumeIssue)
+
+if (needsRepair) {
+  const repairOptions: SessionRepairOptions = item.priority === 'active' && normalizedScan.resumeIssue
+    ? { includeResumeIssues: true }
+    : {}
+  const repairResult = await this.scanner.repair(item.filePath, repairOptions)
+  this.emit('repaired', repairResult)
+
+  // Re-scan to get updated result
+  const newResult = await this.scanner.scan(item.filePath)
+  await this.cache.set(item.filePath, newResult)
+  const normalizedNew = newResult.sessionId === item.sessionId
+    ? newResult
+    : { ...newResult, sessionId: item.sessionId }
+  await this.postScan?.(normalizedNew)
+  this.setProcessed(item.sessionId, normalizedNew)
+  this.resolveWaiting(item.sessionId, normalizedNew)
+} else {
+  await this.postScan?.(normalizedScan)
+  this.setProcessed(item.sessionId, normalizedScan)
+  this.resolveWaiting(item.sessionId, normalizedScan)
+}
+```
+
+Note: The import needs `SessionRepairOptions` from `./types.js`. Add it to the existing import.
+
+3. **Add `clearProcessed(sessionId)` method.** The service layer (Task 4) needs to clear a stale processed result before re-enqueueing a session for active repair. Without this, `queue.waitFor()` would immediately return the stale result from `this.processed` before the re-enqueued item is processed. Add:
+
+```typescript
+/**
+ * Remove a processed result so the session can be re-enqueued and re-awaited.
+ * Used by the service layer to force active-priority re-processing.
+ */
+clearProcessed(sessionId: string): void {
+  this.processed.delete(sessionId)
+}
+```
+
+This is a one-line method but it solves a critical race: `waitFor()` checks `this.processed` first and returns immediately if found. If the service calls `enqueue()` then `waitFor()` without clearing the stale processed entry, `waitFor()` returns the old (resume-issue) result immediately.
+
+- [ ] **Step 4: Run the queue tests to verify they pass**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-queue.test.ts
+```
+
+Expected: All PASS, including all new resume-issue tests and all existing queue tests.
+
+- [ ] **Step 5: Refactor and verify**
+
+Ensure:
+- Orphan repair remains eager for all priorities (no regression)
+- The `SessionRepairOptions` import is clean
+- No duplicate code between the corrupt path and the resume-issue path
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-queue.test.ts
+```
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add \
+  server/session-scanner/queue.ts \
+  test/unit/server/session-queue.test.ts
+git commit -m "feat: gate inline progress repair to active priority in queue"
+```
+
+---
+
+## Chunk 4: Service Layer Gating
+
+### Task 4: Make `waitForSession()` force active repair for cached resume issues
+
+**Files:**
+- Modify: `server/session-scanner/service.ts`
+- Modify: `test/server/ws-terminal-create-session-repair.test.ts`
+
+- [ ] **Step 1: Write the failing service integration test**
+
+Add to `test/server/ws-terminal-create-session-repair.test.ts`:
+
+First, update the `FakeSessionRepairService` to support the new `resumeIssue` field in its default response and add the ability to simulate the transition. The existing fake's `waitForSession` should be able to return results with `resumeIssue: undefined` (post-repair), while `getResult` can return the cached pre-repair result with `resumeIssue: 'inline_stop_hook_progress'`.
+
+```typescript
+it('does not skip resume for healthy sessions with inline-progress resume issue', async () => {
+  // Simulate: getResult returns a cached result with resumeIssue
+  sessionRepairService.result = {
+    sessionId: VALID_SESSION_ID,
+    filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  // waitForSession should still be called because the cached result has a resume issue
+  // After repair, it returns the clean result
+  sessionRepairService.waitForSessionResult = {
+    sessionId: VALID_SESSION_ID,
+    filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+  }
+
+  const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+  try {
+    await new Promise<void>((resolve) => ws.on('open', () => resolve()))
+    await waitForReady(ws)
+
+    const requestId = 'resume-inline-progress-1'
+    const createdPromise = waitForCreated(ws, requestId, 3000)
+    ws.send(JSON.stringify({
+      type: 'terminal.create',
+      requestId,
+      mode: 'claude',
+      resumeSessionId: VALID_SESSION_ID,
+    }))
+
+    const created = await createdPromise
+
+    // Resume should proceed (not be dropped)
+    expect(created.effectiveResumeSessionId).toBe(VALID_SESSION_ID)
+    // waitForSession should have been called despite cached result
+    expect(sessionRepairService.waitForSessionCalls).toContain(VALID_SESSION_ID)
+  } finally {
+    await closeWebSocket(ws)
+  }
+})
+```
+
+Note: This test verifies the ws-handler + service integration. The ws-handler calls `getResult()` first, sees `status: 'healthy'` (not `missing`), then calls `waitForSession()`. The service's `waitForSession()` must not short-circuit on the cached result because it has a `resumeIssue`. This test validates that the full chain works: ws-handler does not drop the resume (because status is healthy), and `waitForSession` is called (because the service forces re-enqueue).
+
+However, looking at the current ws-handler code at line 1297-1322, the ws-handler only checks `cached?.status === 'missing'` from `getResult()`. If the cached status is `'healthy'`, it falls through to `waitForSession()`. So the ws-handler itself does NOT need modification -- it already calls `waitForSession()` for non-missing results. The change is purely in the service's `waitForSession()` method.
+
+But there is a subtlety: `waitForSession()` currently returns immediately if `queue.getResult(sessionId)` returns a processed result. If that result has a `resumeIssue`, the service must NOT return it immediately. Instead, it must re-enqueue at active priority and wait for the repair.
+
+- [ ] **Step 2: Run the integration test to verify it fails**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.server.config.ts test/server/ws-terminal-create-session-repair.test.ts
+```
+
+Expected: This test should actually pass with the existing code because the integration test uses a `FakeSessionRepairService` -- we need to verify the real service behavior. However, the fake service's `getResult()` returns the cached result with `resumeIssue`, and the ws-handler sees `status: 'healthy'` (not missing), so it calls `waitForSession()`. The fake's `waitForSession()` always returns the `waitForSessionResult` which has no `resumeIssue`. So this test may pass even without changes.
+
+The real behavior we need to test is the service's `waitForSession()` method when it finds a cached/processed result with a `resumeIssue`. This is better tested at the unit level. Let me adjust the approach.
+
+Instead, add a focused unit test for the service. But `SessionRepairService` is hard to unit test in isolation because it depends on glob, fs, and the full cache/queue infrastructure. The integration test proves the end-to-end behavior. The key behavior change is in `waitForSession()`.
+
+The fake already simulates the correct behavior (returns clean result from `waitForSession`), so the integration test proves the ws-handler does not drop the resume. What we really need to test is that the REAL service's `waitForSession()` does not return stale cached results with `resumeIssue`. But this is already handled by the queue changes in Task 3 -- when the queue processes an `active` item and the scan/cached result has a `resumeIssue`, it repairs first.
+
+The service-layer change is: in `waitForSession()`, when a processed result is found via `queue.getResult()` and it has a `resumeIssue`, do NOT return it. Instead, re-enqueue at active priority and wait.
+
+Let me adjust the integration test to specifically validate that `waitForSession` is called (which triggers the active-priority repair path):
+
+```typescript
+it('calls waitForSession for healthy cached results with resume issues', async () => {
+  // Pre-populate getResult with a resume-issue result
+  sessionRepairService.result = {
+    sessionId: VALID_SESSION_ID,
+    filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+    resumeIssue: 'inline_stop_hook_progress',
+  }
+
+  sessionRepairService.waitForSessionResult = {
+    sessionId: VALID_SESSION_ID,
+    filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+    status: 'healthy',
+    chainDepth: 5,
+    orphanCount: 0,
+    fileSize: 500,
+    messageCount: 5,
+  }
+
+  const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+  try {
+    await new Promise<void>((resolve) => ws.on('open', () => resolve()))
+    await waitForReady(ws)
+
+    const requestId = 'resume-inline-progress-1'
+    const createdPromise = waitForCreated(ws, requestId, 3000)
+    ws.send(JSON.stringify({
+      type: 'terminal.create',
+      requestId,
+      mode: 'claude',
+      resumeSessionId: VALID_SESSION_ID,
+    }))
+
+    const created = await createdPromise
+
+    expect(created.effectiveResumeSessionId).toBe(VALID_SESSION_ID)
+    expect(sessionRepairService.waitForSessionCalls).toContain(VALID_SESSION_ID)
+  } finally {
+    await closeWebSocket(ws)
+  }
+})
+```
+
+- [ ] **Step 3: Implement the `waitForSession()` bypass for resume issues**
+
+In `server/session-scanner/service.ts`, modify `waitForSession()`:
+
+The first thing `waitForSession()` does is check `queue.getResult(sessionId)`. If the result exists and has a `resumeIssue`, we must NOT return it. Instead, we need to re-enqueue and wait.
+
+Replace the early return at the top of `waitForSession()`:
+
+**Critical:** Before calling `this.queue.waitFor()`, you MUST call `this.queue.clearProcessed(sessionId)` to remove the stale processed entry. Without this, `waitFor()` checks `this.processed` first and returns the stale result immediately, before the re-enqueued item is processed. The sequence must be: `clearProcessed` -> `enqueue` -> `waitFor`.
+
+```typescript
+async waitForSession(sessionId: string, timeoutMs = 30000): Promise<SessionScanResult> {
+  // Check if already processed
+  const existing = this.queue.getResult(sessionId)
+  if (existing) {
+    // If the processed result has a resume issue, force active-priority repair
+    if (existing.resumeIssue) {
+      this.queue.clearProcessed(sessionId)
+      this.queue.enqueue([{ sessionId, filePath: existing.filePath, priority: 'active' }])
+      return this.queue.waitFor(sessionId, timeoutMs)
+    }
+    await this.ensureSessionArtifacts(existing)
+    return existing
+  }
+  // ... rest of method unchanged ...
+```
+
+Also, further down in `waitForSession()`, there is a section that checks `legacyResult` from `queue.getResult(fileSessionId)`. Apply the same check there:
+
+```typescript
+const legacyResult = this.queue.getResult(fileSessionId)
+if (legacyResult) {
+  // If the legacy result has a resume issue, force active-priority repair
+  if (legacyResult.resumeIssue) {
+    this.queue.clearProcessed(fileSessionId)
+    this.queue.enqueue([{ sessionId: fileSessionId, filePath, priority: 'active' }])
+    const result = await this.queue.waitFor(fileSessionId, timeoutMs)
+    const normalized = result.sessionId === sessionId
+      ? result
+      : { ...result, sessionId }
+    this.queue.seedResult(sessionId, normalized)
+    await this.ensureSessionArtifacts(normalized)
+    return normalized
+  }
+  const normalized = legacyResult.sessionId === sessionId
+    ? legacyResult
+    : { ...legacyResult, sessionId }
+  if (fileSessionId !== sessionId) {
+    this.queue.seedResult(sessionId, normalized)
+  }
+  await this.ensureSessionArtifacts(normalized)
+  return normalized
+}
+```
+
+And in the cache check section:
+
+```typescript
+// Check cache for recent result
+const cached = await this.cache.get(filePath, { allowStaleMs: ACTIVE_CACHE_GRACE_MS })
+if (cached) {
+  if (cached.status === 'missing') {
+    this.sessionPathIndex.delete(sessionId)
+  }
+  // If cached result has a resume issue, force active-priority repair
+  if (cached.resumeIssue) {
+    this.queue.clearProcessed(sessionId)
+    this.queue.enqueue([{ sessionId, filePath, priority: 'active' }])
+    return this.queue.waitFor(sessionId, timeoutMs)
+  }
+  const normalized = cached.sessionId === sessionId
+    ? cached
+    : { ...cached, sessionId }
+  this.queue.seedResult(sessionId, normalized)
+  await this.ensureSessionArtifacts(normalized)
+  return normalized
+}
+```
+
+- [ ] **Step 4: Run the integration test to verify it passes**
+
+Run:
+
+```bash
+npm run test:vitest -- --config vitest.server.config.ts test/server/ws-terminal-create-session-repair.test.ts
+```
+
+Expected: All PASS, including the new resume-issue integration test and all existing tests.
+
+- [ ] **Step 5: Refactor and verify**
+
+Ensure:
+- The `resumeIssue` bypass is applied consistently in all code paths through `waitForSession()`
+- No infinite re-enqueue loop is possible (the queue's active-priority processing will repair and produce a result without `resumeIssue`, breaking the cycle)
+- The `SessionScanResult` type change (adding `resumeIssue`) does not break any other consumers
+
+Run both test suites:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts test/unit/server/session-queue.test.ts
+npm run test:vitest -- --config vitest.server.config.ts test/server/ws-terminal-create-session-repair.test.ts
+```
+
+Expected: All PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add \
+  server/session-scanner/service.ts \
+  test/server/ws-terminal-create-session-repair.test.ts
+git commit -m "feat: force active repair path for cached resume issues in service"
+```
+
+---
+
+## Verification
+
+- [ ] Run typechecking:
+
+```bash
+npm run typecheck
+```
+
+Expected: No errors. The type changes (`resumeIssue` on `SessionScanResult`, `resumeIssuesFixed` on `SessionRepairResult`, `options` on `repair()`) are backward-compatible.
+
+- [ ] Run the focused scanner suite:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-scanner.test.ts
+```
+
+- [ ] Run the focused queue suite:
+
+```bash
+npm run test:vitest -- --config vitest.config.ts test/unit/server/session-queue.test.ts
+```
+
+- [ ] Run the server integration suite:
+
+```bash
+npm run test:vitest -- --config vitest.server.config.ts test/server/ws-terminal-create-session-repair.test.ts
+```
+
+- [ ] Check coordinator state, then run the full regression suite:
+
+```bash
+npm run test:status
+FRESHELL_TEST_SUMMARY="inline progress session repair" npm test
+```
+
+---
+
+## Definition of Done
+
+- [ ] Healthy sessions with inline Stop-hook progress on the active chain are classified as `resumeIssue: 'inline_stop_hook_progress'`.
+- [ ] Those sessions remain `status: 'healthy'` unless they also contain real corruption.
+- [ ] Disk and background scans never rewrite healthy-inline-progress session files.
+- [ ] `waitForSession()` does not return a cached inline-progress result directly to `terminal.create`; it forces the active repair path first.
+- [ ] The repair rewrites only `stop_hook_summary.parentUuid`, leaves the `progress` record in place, and is idempotent.
+- [ ] Orphan repair behavior remains unchanged.
+- [ ] Focused unit and server integration suites pass.
+- [ ] `npm run typecheck` passes.
+- [ ] Coordinated `npm test` passes.
diff --git a/docs/plans/2026-03-27-stability-fixes.md b/docs/plans/2026-03-27-stability-fixes.md
new file mode 100644
index 00000000..e7891a44
--- /dev/null
+++ b/docs/plans/2026-03-27-stability-fixes.md
@@ -0,0 +1,218 @@
+# Freshell Stability Fixes — Implementation Plan
+
+**Date:** 2026-03-27
+**Status:** Ready for implementation
+**Context:** Based on 6 investigation spikes. Full findings at `docs/lab-notes/2026-03-27-complete-characterization.md`.
+
+---
+
+## How to Use This Plan
+
+**Work model:** One agent, one branch, serial execution. Work through the issues in order, committing frequently. Each fix builds on the previous ones. The ordering is designed so later fixes benefit from earlier ones (e.g., boot ID enables the handshake snapshot which enables proactive recovery).
+
+**Suggested PR breakpoints:** After Issue 3 (quick wins), after Issue 7 (handshake snapshot — the biggest architectural change), and after Issue 9 (the full set). This gives 3 reviewable PRs that can merge sequentially.
+
+**For each issue, the agent should:**
+1. Read the issue description and the referenced context files (spike lab notes)
+2. Implement with TDD — write a failing test, make it pass, refactor
+3. Build and run a server on a unique port to verify the fix works in a real browser
+4. Use Chrome automation to confirm the user-visible behavior is fixed
+5. Write findings/decisions in a lab note if anything surprising comes up
+6. Commit with a clear message, then move to the next issue
+7. Run the full test suite periodically (at least at each PR breakpoint) to catch regressions
+
+---
+
+## Issue 1: Cache /api/version GitHub response
+
+**What:** `/api/version` calls `https://api.github.com/repos/danshapiro/freshell/releases/latest` on every request. First call is 227ms, subsequent 44ms. No server-side cache.
+
+**Why it matters:** It's the slowest request during page load. A 5-15 minute TTL cache is trivial and eliminates 227ms from every page load.
+
+**Where to look:** `server/updater/version-checker.ts:76` — the `checkForUpdate()` function. Also `server/platform-router.ts:41` where the endpoint is defined.
+
+**How to verify:** Start the server, call `GET /api/version` twice in quick succession with curl. First call should hit GitHub. Second call within TTL should return cached result in <1ms. Check server logs confirm no second GitHub fetch.
+
+**Constraints:** Don't change the response format. Just add an in-memory cache with a TTL.
+
+---
+
+## Issue 2: Fix "Recovering terminal output..." on fresh terminals
+
+**What:** The "Recovering terminal output..." banner briefly flashes on every new terminal creation, not just reconnects.
+
+**Why it matters:** It makes every terminal creation look like something went wrong. On LAN/VPN it's clearly visible (100-500ms).
+
+**Where to look:** `src/components/TerminalView.tsx:1995` — the banner render condition. The root cause is that `status` transitions to `'running'` before the attach completes, making `status !== 'creating' && isAttaching` true during the create→attach window. Spike 3 lab note (`docs/lab-notes/2026-03-27-spike-3-terminal-rendering.md`) has the full code path trace with line numbers.
+
+**How to verify:** Build, run server, open in Chrome. Create a new shell terminal. The "Recovering" banner should NOT appear. Reconnect scenarios (WS drop, server restart) SHOULD still show the banner — don't break that.
+
+**Constraints:** The fix should distinguish "first attach of a brand-new terminal" from "re-attach after disconnect." The intent parameter (`viewport_hydrate` vs `transport_reconnect`) or a "has this terminal ever been live" flag could work. Don't overcomplicate — this is a one-line-condition fix.
+
+---
+
+## Issue 3: Reduce session-directory over-polling
+
+**What:** The session indexer broadcasts `sessions_changed` every 5-8 seconds. Every browser tab re-fetches the full `/api/session-directory` (~73KB with 720 sessions) on each broadcast. That's ~660KB/min per tab during complete idle.
+
+**Why it matters:** It's the single biggest source of steady-state waste. Constant unnecessary network traffic and client-side JSON parsing. Scales linearly with browser tab count.
+
+**Where to look:**
+- Server: the indexer's broadcast frequency — find where `sessions_changed` is emitted and why it fires every 5-8s even when nothing changed
+- Client: `sessionsThunks.ts:372` — `queueActiveSessionWindowRefresh()` which triggers the re-fetch. Also the handler in `App.tsx:727-728`
+- The existing delta sync system (`sessions-sync/`) — it may already have the right primitives
+
+**Possible approaches (pick the best one, don't overbuild):**
+- Server sends a content hash with `sessions_changed`; client skips fetch if hash matches
+- Server doesn't broadcast `sessions_changed` if nothing actually changed since last broadcast
+- Client debounces more aggressively (e.g., once per 30s instead of every broadcast)
+- Use the revision number that's already in the message — client only re-fetches if revision increased
+
+**How to verify:** Start server, open in Chrome. Install a fetch interceptor (`window.fetch` wrapper) or check network tab. During 60 seconds of idle, count `/api/session-directory` requests. Should be dramatically fewer than the current ~9/min. Verify sidebar still updates when actual session changes happen (create a Claude session in another terminal, confirm it appears in sidebar).
+
+**Constraints:** Don't break the sidebar. Sessions must still show up promptly when they actually change. The goal is to eliminate redundant fetches, not delay real updates.
+
+---
+
+## Issue 4: Add per-process boot ID to server `ready` message
+
+**What:** `serverInstanceId` is loaded from `~/.freshell/instance-id` on disk, so it's the same across server restarts. The client can't distinguish "reconnect to same server" from "server restarted, all terminals gone."
+
+**Why it matters:** Without this, the client must discover dead terminals one-by-one via INVALID_TERMINAL_ID errors. With a per-process ID, the client knows immediately that all terminals are gone and can skip the attach→error→create cascade.
+
+**Where to look:**
+- Server: where `serverInstanceId` is generated/loaded. It's in the server startup code and sent in the `ready` message at `ws-handler.ts:1071-1076`
+- Client: `ws-client.ts` ready handler and `App.tsx` ready handler where `serverInstanceId` is captured and compared
+
+**How to verify:** Start server, connect client, note the serverInstanceId. Kill server, restart. Connect again. The `ready` message should have a DIFFERENT serverInstanceId. The client should detect the change. (The client-side behavior change — what to DO with this detection — is Issue 7. This issue just makes the detection possible.)
+
+**Constraints:** Don't break any existing behavior that depends on serverInstanceId being stable. Check if anything uses it for persistent identity (device tracking, tab sync). If so, keep the persistent ID for those uses and add a separate `bootId` or `processId` field to the `ready` message.
+
+---
+
+## Issue 5: Guard cross-tab sync against cross-kind pane overwrites
+
+**What:** `mergeTerminalState()` in `panesSlice.ts` guards terminal↔terminal and agent-chat↔agent-chat transitions but silently allows cross-kind overwrites (e.g., terminal→browser). This can corrupt a Shell pane into a Browser pane during cross-tab sync.
+
+**Why it matters:** This is the most severe data integrity bug found. A user's terminal pane becomes a "Enter a URL to browse" pane during reconnect recovery.
+
+**Where to look:** `src/store/panesSlice.ts:405-485` — the `mergeTerminalState()` function. Also `hydratePanes` reducer. Spike 5 lab note (`docs/lab-notes/2026-03-27-spike-5-data-flow-tracing.md`) has the full mechanism trace.
+
+**How to verify:** Write a unit test that calls `mergeTerminalState()` with local `kind: 'terminal'` and incoming `kind: 'browser'` — it should preserve the local content, not overwrite. Also test the reverse. Then test that same-kind merges (terminal↔terminal) still work as before.
+
+**Constraints:** Think carefully about what the RIGHT behavior is for cross-kind transitions. Options: (a) always prefer local, (b) always prefer the newer one (needs a timestamp), (c) prefer whichever has a live terminal. The simplest correct answer is probably: if the local pane has an active terminal (terminalId is set and status is running), never overwrite it with a different kind.
+
+---
+
+## Issue 6: Make cross-tab hydration atomic for tabs + panes
+
+**What:** `persistMiddleware` writes tabs and panes in one flush, but cross-tab sync processes them as separate storage events. Between the two hydrations, the receiving tab has inconsistent state (tab exists but layout is gone, or vice versa). This can cause unmount cascades and "offline reconnecting" in other tabs.
+
+**Why it matters:** Closing a pane in one browser tab can crash another tab's rendering. The spike 5 lab note documents the mechanism.
+
+**Where to look:**
+- `src/store/persistMiddleware.ts` — the flush logic that writes both keys
+- `src/store/crossTabSync.ts` — how storage events are processed per-key
+- The `BroadcastChannel` path vs the `StorageEvent` path
+
+**Possible approaches:**
+- Bundle tabs + panes into a single localStorage key (simplest, but migration needed)
+- Use BroadcastChannel to send both as one message, and only hydrate when both arrive
+- Add a sequence number to both writes; receiving tab waits for matching sequence before hydrating
+
+**How to verify:** Open Freshell in two browser tabs. In tab 1, close a pane or tab that tab 2 is also showing. Tab 2 should NOT flash "offline" or break its layout. It should smoothly remove the closed element.
+
+**Constraints:** Don't break the existing cross-tab sync for normal operations (tab creation, rename, etc.). The fix should make the sync MORE reliable, not add new failure modes.
+
+---
+
+## Issue 7: Add terminal inventory to handshake snapshot
+
+**What:** After `ready`, the server sends settings and that's it. The client has no idea what terminals exist. It discovers state reactively by trying to attach stale IDs and getting INVALID_TERMINAL_ID errors.
+
+**Why it matters:** This is the core architectural gap that causes the reconnect cascade. The server can assemble terminal state in <1ms (spike 4 confirmed this). Adding it to the handshake eliminates the entire INVALID_TERMINAL_ID cascade.
+
+**Where to look:**
+- Server: `ws-handler.ts:962-978` — `sendHandshakeSnapshot()`. Also the terminal registry's `list()` method.
+- Client: `App.tsx` ready handler. Also `src/store/terminalDirectorySlice.ts` and `src/store/terminalMetaSlice.ts` which have snapshot actions (`setTerminalMetaSnapshot`) that are wired but never called.
+- Spike 4 lab note (`docs/lab-notes/2026-03-27-spike-4-server-audit.md`) has the analysis.
+- Spike 6 lab note (`docs/lab-notes/2026-03-27-spike-6-consistency-audit.md`) documents the `terminalMetaListProvider` that's plumbed but unused.
+
+**What to include in the snapshot:**
+- Terminal list: id, mode, status (running/exited), title, resumeSessionId, createdAt
+- Terminal metadata: cwd, branch, provider, sessionId, tokenUsage
+- A per-process boot ID (from Issue 4) so the client knows if this is the same server
+
+**Client behavior on receiving snapshot:**
+- If boot ID matches previous: reconcile. Terminals in snapshot are alive; terminals NOT in snapshot are dead. Skip INVALID_TERMINAL_ID cascade — go straight to create for dead terminals.
+- If boot ID is new: all previous terminals are gone. Don't even try to attach old IDs.
+- Populate terminal metadata from snapshot (call `setTerminalMetaSnapshot`).
+
+**How to verify:** Start server, create 3 terminals. Kill server, restart. The client should recover ALL terminals without any INVALID_TERMINAL_ID errors in the console. The recovery should be visibly faster (no cascade). Use Chrome automation to time it — compare against spike 1 measurements.
+
+**Constraints:** This depends on Issue 4 (boot ID). Must be backward-compatible — if the client connects to an older server that doesn't send the snapshot, the old reactive behavior should still work. Add a capability flag or just check if the snapshot field exists in the ready message.
+
+---
+
+## Issue 8: Reconnect backoff tuning
+
+**What:** Exponential backoff 1s→2s→4s→8s means a 5-second server restart causes 15s+ of client-side waiting. The server sends close code 4009 ("server shutting down") which resets backoff, but subsequent failures re-escalate.
+
+**Why it matters:** 93% of the server restart recovery time is spent waiting in backoff timers.
+
+**Where to look:** `src/lib/ws-client.ts` — the `scheduleReconnect()` function and the backoff logic.
+
+**Possible approaches:**
+- Cap max backoff at 4s instead of growing indefinitely
+- After a 4009 close code, use faster retry (500ms intervals for the first 10 attempts)
+- Add jitter to prevent thundering herd
+- Probe with faster retries (1s intervals) after detecting server shutdown, then fall back to exponential only after 30s
+
+**How to verify:** Kill server, time how long until client reconnects after restart. Should be under 5s for a 3s server restart, not 15s+.
+
+**Constraints:** Don't create a reconnect storm. If the server is genuinely down for a long time, exponential backoff is still correct — just tune the initial parameters for the common case (brief restart).
+
+---
+
+## Issue 9: Proactive hidden-tab recovery
+
+**What:** Only the active tab goes through reconnect recovery (INVALID→create→attach). Hidden tabs are left broken until the user switches to them, at which point they replay the full buffer (the fast-scroll symptom).
+
+**Why it matters:** Every tab switch after a server restart shows broken/replaying content. The user has to wait for each tab to recover individually.
+
+**Where to look:** `src/components/TerminalView.tsx:1868-1883` — the reconnect handler that checks `hiddenRef.current` and defers attach. Also the `useEffect` at line 1431-1446 that fires the deferred attach on visibility change.
+
+**How to verify:** Start server, create 3 terminals across 3 tabs. Kill server, restart. After the active tab recovers, switch to the other tabs. They should already be recovered (or recover instantly without visible replay).
+
+**Constraints:** This is closely related to Issue 7 (handshake snapshot). With a snapshot, the client knows which terminals are dead immediately and can proactively re-create ALL of them, not just the visible one. Implement this after Issue 7 — the snapshot makes the proactive recovery much cleaner because you don't need to try-and-fail for each hidden terminal.
+
+---
+
+## Serial Order and PR Breakpoints
+
+The issues are ordered so each builds on the last:
+
+```
+PR 1 — Quick Wins (Issues 1-3)
+  1. /api/version cache              — trivial, immediate page load improvement
+  2. "Recovering" banner fix         — cosmetic, builds confidence
+  3. Session-directory over-polling   — biggest steady-state fix
+
+PR 2 — Architectural Core (Issues 4-7)
+  4. Per-process boot ID             — enables server restart detection
+  5. Cross-kind merge guard          — prevents pane corruption
+  6. Atomic cross-tab hydration      — prevents cross-tab breakage
+  7. Handshake terminal snapshot     — the big one: eliminates INVALID cascade
+
+PR 3 — Recovery Polish (Issues 8-9)
+  8. Reconnect backoff tuning        — faster reconnect after restart
+  9. Proactive hidden-tab recovery   — no more replay-on-switch
+```
+
+## Verification Checklist (At Each PR Breakpoint)
+
+- [ ] Full test suite passes (`npm test`)
+- [ ] Server builds and runs in production mode
+- [ ] All fixed behaviors verified in Chrome with real terminals
+- [ ] No regression in: reconnect, page refresh, cross-tab sync, terminal output
+- [ ] Each commit has a clear message explaining what and why
diff --git a/docs/plans/2026-03-27-title-search-subdir-tabs-test-plan.md b/docs/plans/2026-03-27-title-search-subdir-tabs-test-plan.md
new file mode 100644
index 00000000..da9f8c0b
--- /dev/null
+++ b/docs/plans/2026-03-27-title-search-subdir-tabs-test-plan.md
@@ -0,0 +1,133 @@
+# Title Search Subdirectory And Open-Tab Search Behavior Revised Test Plan
+
+Minor reconciliation adjustment: the prior strategy still holds on scope, harness cost, and external dependencies, but the revised implementation plan changes test priority. The blocking contract is now the sidebar window commit model and visible-refresh identity, so the first gates move to `sessionsSlice`, `sessionsThunks`, and the full-app drift scenario. The already-landed leaf-directory matcher, selector fallback gating, and server transport checks remain regression coverage after those red checks.
+
+## Harness requirements
+
+No new harness families are required. Extend the existing local Vitest harnesses with low-complexity fixtures that expose the explicit visible-result identity and drift timing called for by the revised implementation plan.
+
+- **Explicit window-commit reducer harness**: `test/unit/client/store/sessionsSlice.test.ts`. Dispatch reducer actions directly and assert `query`, `searchTier`, `appliedQuery`, `appliedSearchTier`, `loading/loadingKind`, top-level active-surface sync, and the committed result-set token (`resultVersion`, or the final equivalent explicit field name if renamed during refactor). Estimated complexity: low. Depends on tests 1 and 4.
+- **Refresh-drift thunk harness**: `test/unit/client/store/sessionsThunks.test.ts`. Redux store with deferred promises, captured `AbortSignal`s, and ordered resolution for replacement requests, direct refreshes, queued invalidations, and stale responses. Estimated complexity: low-medium fixture expansion. Depends on tests 2-5.
+- **Full app invalidation harness**: `test/e2e/open-tab-session-sidebar-visibility.test.tsx`. Mount real `App` and `Sidebar`, drive the actual search input and clear button, and trigger websocket invalidation plus direct thunk refresh while observing rendered rows and search chrome. Estimated complexity: low fixture tightening. Depends on test 6.
+- **Sidebar search-flow harness**: `test/e2e/sidebar-search-flow.test.tsx`. Real `Sidebar` with mocked `searchSessions` and `fetchSidebarSessionsSnapshot`, fake timers for debounce, and real DOM typing/tier-change/clear interactions. Estimated complexity: none beyond reusing the current branch coverage. Depends on test 7.
+- **Selector harness**: `test/unit/client/store/selectors/sidebarSelectors.test.ts`. Pure selector fixtures spanning server rows, synthesized fallback rows, sort modes, archived rows, and requested/applied drift. Estimated complexity: low. Depends on tests 8-9.
+- **HTTP router harness**: `test/integration/server/session-directory-router.test.ts`. Express round-trip via `supertest` against `/api/session-directory`. Estimated complexity: none beyond fixture reuse. Depends on test 10.
+- **Service harness**: `test/unit/server/session-directory/service.test.ts`. Direct `querySessionDirectory()` calls with project, provider, file, and large-corpus fixtures. Estimated complexity: low. Depends on test 11.
+- **Shared matcher harness**: `test/unit/shared/session-title-search.test.ts`. Pure metadata/path fixtures for cross-platform leaf extraction and metadata precedence. Estimated complexity: none beyond current coverage. Depends on test 12.
+
+## Test plan
+
+1. **Name:** Replacement and visible-refresh commits keep requested state, applied state, and committed result identity distinct
+   **Type:** unit
+   **Disposition:** extend
+   **Harness:** Explicit window-commit reducer harness
+   **Preconditions:** A sidebar window with committed search results for query `alpha`, `appliedQuery/appliedSearchTier` set to that visible result set, and a known committed result token. A second state also represents an in-flight browse replacement (`query=''`, `loadingKind='search'`) while the `alpha` results are still visible.
+   **Actions:** Dispatch the explicit replacement-loading action with query `beta`; dispatch the replacement-commit action with `beta` data; dispatch the visible-refresh-commit action against the still-visible `alpha` context while preserving replacement loading; dispatch replacement failure/error after requested state has moved but before a new commit lands.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract and Task 1. Replacement loading updates only requested `query/searchTier`; replacement commit updates both requested and applied search state and increments the committed result token; visible-refresh commit updates projects and increments the committed result token without rewriting requested `query/searchTier` or clearing a preserved replacement load; failure preserves the last applied visible context and current committed result token.
+   **Interactions:** Reducer API shape, active-surface top-level sync, loading semantics, and the explicit result-set identity field that later thunk tests depend on.
+
+2. **Name:** Direct refresh during search-to-browse drift revalidates the visible search result set without aborting the pending browse replacement
+   **Type:** integration
+   **Disposition:** extend
+   **Harness:** Refresh-drift thunk harness
+   **Preconditions:** The store has committed `alpha` title-search results on screen, requested state has already moved to browse (`query=''`, `searchTier='title'`) because `fetchSessionWindow()` for browse was dispatched and left in flight, and the browse request's `AbortSignal` is captured.
+   **Actions:** Dispatch `refreshActiveSessionWindow()` while the browse replacement is still pending; resolve the refresh first; then resolve the browse replacement.
+   **Expected outcome:** Source of truth: user transcript plus revised implementation plan Behavior Contract and Task 2. The refresh fetches using the visible applied context (`alpha`, title tier), does not abort the pending browse request, does not rewrite requested browse state, keeps `appliedQuery/appliedSearchTier` on `alpha` after refresh commit, and still allows the original browse replacement to resolve and finally clear the applied search state.
+   **Interactions:** `refreshActiveSessionWindow()`, visible-context capture, surface abort-controller ownership, reducer commit boundary, and browse replacement sequencing.
+
+3. **Name:** Queued websocket invalidation during the same drift obeys the same no-abort, no-requested-rewrite contract
+   **Type:** integration
+   **Disposition:** extend
+   **Harness:** Refresh-drift thunk harness
+   **Preconditions:** Same as test 2, except the refresh is triggered through `queueActiveSessionWindowRefresh()` while a browse replacement is already in flight.
+   **Actions:** Dispatch `queueActiveSessionWindowRefresh()` during the drift; resolve the queued visible refresh; then resolve the pending browse replacement.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract and Task 2. The queued invalidation revalidates the visible applied result set instead of routing back through the replacement path, does not abort the pending browse replacement, keeps requested state cleared, keeps applied search state on the visible search results until the browse replacement commits, and coalesces through the existing invalidation runner rather than spawning a second browse replacement.
+   **Interactions:** Websocket invalidation path, queue state, in-flight request coordination, visible-refresh helper reuse, and reducer commit sequencing.
+
+4. **Name:** Stale visible refresh responses are dropped once a newer visible result set has committed
+   **Type:** invariant
+   **Disposition:** extend
+   **Harness:** Refresh-drift thunk harness plus explicit window-commit reducer harness
+   **Preconditions:** A committed visible result set with an explicit result token is on screen. A visible refresh for that result set is started and held. Before it resolves, a newer replacement or refresh commits a different visible window and increments the committed result token.
+   **Actions:** Start the older visible refresh; commit the newer window; then resolve the older refresh response.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract and Strategy Gate. The stale refresh is discarded because the visible identity captured at refresh start no longer matches the currently committed visible identity. The newer committed projects, applied search context, and committed result token remain unchanged.
+   **Interactions:** Visible-result identity capture, monotonic committed result token, stale-response suppression, and commit-authority rules across reducer and thunk seams.
+
+5. **Name:** Visible deep-search refreshes stay two-phase and remain keyed to the visible applied context, not requested drift
+   **Type:** integration
+   **Disposition:** extend
+   **Harness:** Refresh-drift thunk harness
+   **Preconditions:** The store is showing committed deep-search (`userMessages` or `fullText`) results for query `alpha`, and requested state can drift independently while that deep-search result set remains visible.
+   **Actions:** Dispatch a visible refresh against the deep-search result set; resolve Phase 1 title results, then Phase 2 deep results; repeat with requested state drifting while the original deep-search result set is still visible.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract and unchanged two-phase deep-search behavior in the current branch. The refresh uses the visible applied query and tier, preserves `deepSearchPending` semantics, does not rewrite requested state during drift, and only commits while the captured visible identity is still current.
+   **Interactions:** Two-phase search merge, deep-search pending indicator state, visible-refresh helper, and requested-vs-applied drift handling.
+
+6. **Name:** Clearing search leaves stale search rows visible, silent refresh keeps them visible, and the browse replacement commits afterward in the full app
+   **Type:** scenario
+   **Disposition:** extend
+   **Harness:** Full app invalidation harness
+   **Preconditions:** `App` is mounted with committed sidebar title-search results, search input populated from requested/applied state, and mocked browse plus refresh requests held as deferred promises.
+   **Actions:** Clear the search input through the real `Clear search` button or equivalent input change path; wait for the browse replacement to start; trigger a websocket `sessions.changed` invalidation or direct `refreshActiveSessionWindow()` while the browse request is still pending; resolve the silent refresh; then resolve the browse replacement.
+   **Expected outcome:** Source of truth: user transcript plus revised implementation plan Behavior Contract. Clearing search starts exactly one browse replacement request and leaves the old search rows visible; the refresh keeps those rows visible and does not show search-loading chrome; after the refresh resolves, the browse replacement still commits and the applied search state finally clears in the rendered sidebar.
+   **Interactions:** Real `Sidebar` search input and clear action, `App` websocket listener, `queueActiveSessionWindowRefresh()` and `refreshActiveSessionWindow()`, Redux state propagation, and rendered DOM assertions.
+
+7. **Name:** Searching by a subdirectory leaf returns indexed sessions and only matching open-tab fallback rows, without pinning tabs above newer server results
+   **Type:** scenario
+   **Disposition:** existing
+   **Harness:** Sidebar search-flow harness
+   **Preconditions:** A rendered sidebar with one indexed server session whose title does not contain `trycycle` but whose `projectPath` or distinct `cwd` leaf does; a newer non-tab server result; one open fallback tab whose local metadata leaf also matches `trycycle`; and a second query `code` that appears only in ancestor path segments.
+   **Actions:** Type `trycycle` into the search input and wait for debounce plus the title-tier server response; inspect ordered rows. Replace the query with `code` and wait for the next response.
+   **Expected outcome:** Source of truth: user transcript and revised implementation plan Behavior Contract. `trycycle` returns the indexed session and the locally provable fallback row; `code` does not match that same session or fallback row on ancestor-only path text; and during the applied search the matching fallback row is not pinned ahead of the newer non-tab server result.
+   **Interactions:** Search debounce, title-tier request payload, selector fallback synthesis, applied-search pinning rules, and DOM row ordering.
+
+8. **Name:** Applied title search only injects fallback rows that the client can prove locally, and requested-state drift does not change the visible filtered set early
+   **Type:** invariant
+   **Disposition:** existing
+   **Harness:** Selector harness
+   **Preconditions:** Selector state contains server rows, matching and non-matching fallback rows, requested state intentionally different from applied state, and an applied title-search query whose local proof succeeds for only a subset of fallbacks.
+   **Actions:** Run `makeSelectSortedSessionItems()` with applied title-search state while requested `query/searchTier` differ from applied fields.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract. The selector filters fallback rows based on `appliedQuery/appliedSearchTier`, not requested drift; only locally provable title-tier fallback rows remain; unrelated fallbacks and ancestor-only matches stay hidden; and visible ordering still respects no-pinning during applied search.
+   **Interactions:** Applied-vs-requested selector inputs, fallback proof via shared title matcher, sort comparator behavior, and synthesized fallback row construction.
+
+9. **Name:** Applied deep-search result sets never inject fallback tabs and search disables tab pinning while preserving archived-last ordering
+   **Type:** invariant
+   **Disposition:** existing
+   **Harness:** Selector harness
+   **Preconditions:** Selector state contains a deep-search result set, fallback tabs whose local metadata would match the query, a newer non-tab row, an archived row, and both `activity` and `recency-pinned` sort modes.
+   **Actions:** Run the selector for applied deep-search state, then for applied title-search state, and compare the sorted outputs across sort modes.
+   **Expected outcome:** Source of truth: revised implementation plan Behavior Contract. Deep-search tiers show only server-authoritative rows; title-tier applied search may include locally provable fallback rows; applied search disables `hasTab` pinning in both sort modes; and archived rows still sort last.
+   **Interactions:** Applied search tier gating, fallback suppression, tab-pinning comparator options, and archived grouping.
+
+10. **Name:** `/api/session-directory` matches leaf directory names and rejects ancestor-only path text through the real HTTP transport contract
+    **Type:** integration
+    **Disposition:** existing
+    **Harness:** HTTP router harness
+    **Preconditions:** The Express route is mounted with indexed sessions whose `projectPath` leaf is `trycycle`, whose titles omit that term, and whose ancestor path contains `code`.
+    **Actions:** Send `GET /api/session-directory?priority=visible&query=trycycle&tier=title`; then send the same request with `query=code`.
+    **Expected outcome:** Source of truth: user transcript, revised implementation plan Behavior Contract, and the `SessionDirectoryPage` schema. The `trycycle` request returns the matching item with the existing HTTP shape and `matchedIn/snippet` semantics; the `code` request returns no match when the only occurrence is an ancestor-only path segment.
+    **Interactions:** Router query parsing, service invocation, read-model schema stability, and title-tier metadata search over the real HTTP endpoint the sidebar consumes.
+
+11. **Name:** Service-level title-tier search stays provider-free, preserves metadata precedence and ordering, and keeps the existing low-risk performance guard
+    **Type:** integration
+    **Disposition:** existing
+    **Harness:** Service harness
+    **Preconditions:** `querySessionDirectory()` fixtures cover title matches, project-path leaf matches, distinct `cwd` leaf matches, summary matches, first-user-message matches, archived sessions, and a large-enough corpus for the existing generous timing guard.
+    **Actions:** Query the service with title-tier searches that hit each metadata source, with an ancestor-only query, and with providers omitted; run the existing large-corpus timing check.
+    **Expected outcome:** Source of truth: revised implementation plan Behavior Contract and current `querySessionDirectory()` transport contract. Metadata precedence remains `title`, then project-path leaf, then distinct `cwd` leaf, then `summary`, then `firstUserMessage`; title-tier search stays provider-free; ancestor-only path text does not match; canonical ordering and archived handling remain unchanged; and the existing generous timing guard still passes, catching only catastrophic regressions.
+    **Interactions:** Server projection ordering, snippet extraction, provider lookup bypass for title tier, and metadata-search cost.
+
+12. **Name:** Shared title-tier metadata matching extracts cross-platform leaf directory names and rejects ancestor-only segments
+    **Type:** unit
+    **Disposition:** existing
+    **Harness:** Shared matcher harness
+    **Preconditions:** Pure metadata fixtures cover POSIX paths, Windows paths, trailing separators, sessions with both `projectPath` and deeper `cwd`, fallback-only metadata with only `cwd`, and an ancestor-only query.
+    **Actions:** Call `getLeafDirectoryName()` and `matchTitleTierMetadata()` across those fixtures.
+    **Expected outcome:** Source of truth: user transcript and revised implementation plan Behavior Contract. Leaf extraction returns the final directory name on POSIX and Windows inputs, ignores trailing separators, prefers the indexed `projectPath` leaf over a deeper `cwd` leaf when both exist, still matches fallback-only `cwd` metadata, and returns `null` for ancestor-only segments such as `code`.
+    **Interactions:** Shared matcher seam used by both client fallback gating and server title-tier search.
+
+## Coverage summary
+
+- **Covered action space:** typing into the sidebar search input; changing the requested search tier; clearing the search input to start a browse replacement; dispatching `refreshActiveSessionWindow()` directly; receiving websocket `sessions.changed` invalidations that flow through `queueActiveSessionWindowRefresh()`; resolving replacement requests, visible refreshes, and stale responses in different orders; rendering search rows and silent-refresh chrome in the mounted app; computing selector-visible rows and sort order from applied search state; calling `GET /api/session-directory`; executing `querySessionDirectory()` title-tier search; and running the shared leaf-directory matcher.
+- **Covered high-risk boundaries:** reducer commit semantics for requested versus applied search state, abort-controller ownership for direct replacements versus visible refreshes, invalidation queueing, stale response suppression by explicit visible-result identity, client/server agreement on leaf-directory title-tier matching, and selector fallback injection during applied search.
+- **Explicitly excluded:** click-to-open session row behavior, context-menu mutation UX itself, terminal-directory busy-state rendering, and deep file-content search correctness beyond the unchanged two-phase refresh and fallback-suppression contract. Those surfaces are not being changed by this task and already have dedicated coverage elsewhere.
+- **Risk carried by the exclusions:** a regression isolated to session-opening, context-menu presentation, busy indicators, or unrelated deep-search file scanning could land alongside this change without this plan catching it. This plan is intentionally concentrated on the search/filter/refresh contract the user asked to fix and the revised implementation plan now makes explicit.
diff --git a/docs/skills/testing.md b/docs/skills/testing.md
index 56f7ebba..5bb301a7 100644
--- a/docs/skills/testing.md
+++ b/docs/skills/testing.md
@@ -6,6 +6,7 @@
 
 | Command | Purpose |
 |---------|---------|
+| `npm run typecheck:client` | Cheap client-only compile gate; safe while prod is live |
 | `npm test` | Coordinated full suite (`vitest run` plus `vitest run --config vitest.server.config.ts`) |
 | `npm run test:all` | Alias for the same coordinated full suite |
 | `npm run check` | Run `typecheck`, then the coordinated full suite |
@@ -31,12 +32,14 @@
 
 1. Run `npm run test:status` if you need to know whether another agent is already holding the coordinated gate.
 2. Set `FRESHELL_TEST_SUMMARY="why this run matters"` before broad runs so holder/status output is readable.
-3. Use the narrowest truthful public command you can.
-4. If another holder is active, wait rather than killing a foreign process.
+3. Use `npm run typecheck:client` when you only need the cheap frontend compile gate.
+4. Use the narrowest truthful public command you can.
+5. If another holder is active, wait rather than killing a foreign process.
 
 ## Focused Examples
 
 ```bash
+npm run typecheck:client
 FRESHELL_TEST_SUMMARY="Verify coordinated full suite" npm test
 npm run test:server -- --help
 npm run test:server -- --run
diff --git a/package-lock.json b/package-lock.json
index 32ce82ba..75df5123 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "freshell",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "freshell",
-      "version": "0.6.0",
+      "version": "0.7.0",
       "dependencies": {
         "@ai-sdk/google": "^3.0.29",
         "@anthropic-ai/claude-agent-sdk": "^0.2.40",
@@ -2372,9 +2372,9 @@
       }
     },
     "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.27.1",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.27.1.tgz",
-      "integrity": "sha512-sr6GbP+4edBwFndLbM60gf07z0FQ79gaExpnsjMGePXqFcSSb7t6iscpjk9DhFhwd+mTEQrzNafGP8/iGGFYaA==",
+      "version": "1.28.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.28.0.tgz",
+      "integrity": "sha512-gmloF+i+flI8ouQK7MWW4mOwuMh4RePBuPFAEPC6+pdqyWOUMDOixb6qZ69owLJpz6XmyllCouc4t8YWO+E2Nw==",
       "license": "MIT",
       "dependencies": {
         "@hono/node-server": "^1.19.9",
@@ -9271,9 +9271,9 @@
       "license": "CC0-1.0"
     },
     "node_modules/hono": {
-      "version": "4.12.8",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.8.tgz",
-      "integrity": "sha512-VJCEvtrezO1IAR+kqEYnxUOoStaQPGrCmX3j4wDTNOcD1uRPFpGlwQUIW8niPuvHXaTUxeOUl5MMDGrl+tmO9A==",
+      "version": "4.12.9",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.9.tgz",
+      "integrity": "sha512-wy3T8Zm2bsEvxKZM5w21VdHDDcwVS1yUFFY6i8UobSsKfFceT7TOwhbhfKsDyx7tYQlmRM5FLpIuYvNFyjctiA==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"
@@ -14149,9 +14149,9 @@
       }
     },
     "node_modules/router/node_modules/path-to-regexp": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.3.0.tgz",
-      "integrity": "sha512-7jdwVIRtsP8MYpdXSwOS0YdD0Du+qOoF/AEPIt88PcCFrZCzx41oxku1jD88hZBwbNUIEfpqvuhjFaMAqMTWnA==",
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.0.tgz",
+      "integrity": "sha512-PuseHIvAnz3bjrM2rGJtSgo1zjgxapTLZ7x2pjhzWwlp4SJQgK3f3iZIQwkpEnBaKz6seKBADpM4B4ySkuYypg==",
       "license": "MIT",
       "funding": {
         "type": "opencollective",
diff --git a/server/index.ts b/server/index.ts
index 75cd5c70..19f50ce9 100644
--- a/server/index.ts
+++ b/server/index.ts
@@ -46,7 +46,7 @@ import { getNetworkHost } from './get-network-host.js'
 import { PortForwardManager } from './port-forward.js'
 import { parseTrustProxyEnv } from './request-ip.js'
 import { createTabsRegistryStore } from './tabs-registry/store.js'
-import { checkForUpdate } from './updater/version-checker.js'
+import { checkForUpdate, createCachedUpdateChecker } from './updater/version-checker.js'
 import { SessionAssociationCoordinator } from './session-association-coordinator.js'
 import { loadOrCreateServerInstanceId } from './instance-id.js'
 import { createSettingsRouter } from './settings-router.js'
@@ -427,7 +427,7 @@ async function main() {
     detectPlatform,
     detectAvailableClis: () => detectAvailableClis(cliDetectionSpecs),
     detectHostName,
-    checkForUpdate,
+    checkForUpdate: createCachedUpdateChecker(checkForUpdate),
     appVersion: APP_VERSION,
   }))
 
diff --git a/server/mcp/freshell-tool.ts b/server/mcp/freshell-tool.ts
index b6d818cb..0c048179 100644
--- a/server/mcp/freshell-tool.ts
+++ b/server/mcp/freshell-tool.ts
@@ -750,8 +750,13 @@ async function routeAction(
         // For screenshot aliases, inject scope from the alias name
         if (action.startsWith('screenshot-')) {
           const scope = action.replace('screenshot-', '')
-          return routeAction(resolved, { ...params, scope })
+          const mergedParams = { ...params, scope }
+          const aliasParamError = validateParams(resolved, mergedParams)
+          if (aliasParamError) return aliasParamError
+          return routeAction(resolved, mergedParams)
         }
+        const aliasParamError = validateParams(resolved, params)
+        if (aliasParamError) return aliasParamError
         return routeAction(resolved, params)
       }
       return {
diff --git a/server/session-directory/service.ts b/server/session-directory/service.ts
index 24442801..ad004d1f 100644
--- a/server/session-directory/service.ts
+++ b/server/session-directory/service.ts
@@ -3,6 +3,7 @@ import type { ProjectGroup } from '../coding-cli/types.js'
 import type { TerminalMeta } from '../terminal-metadata-service.js'
 import { extractSnippet, searchSessionFile } from '../session-search.js'
 import { MAX_DIRECTORY_PAGE_ITEMS } from '../../shared/read-models.js'
+import { matchTitleTierMetadata } from '../../shared/session-title-search.js'
 import {
   buildSessionDirectoryComparableSnapshot,
   compareSessionDirectoryComparableItems,
@@ -63,20 +64,13 @@ function compareItems(a: SessionDirectoryItem, b: SessionDirectoryItem): number
 }
 
 function applySearch(item: SessionDirectoryItem, queryText: string): SessionDirectoryItem | null {
-  const normalizedQuery = queryText.toLowerCase()
-  const searchable: Array<[SessionDirectoryItem['matchedIn'], string | undefined]> = [
-    ['title', item.title],
-    ['summary', item.summary],
-    ['firstUserMessage', item.firstUserMessage],
-  ]
-
-  const match = searchable.find(([, value]) => typeof value === 'string' && value.toLowerCase().includes(normalizedQuery))
-  if (!match || !match[1]) return null
+  const match = matchTitleTierMetadata(item, queryText)
+  if (!match) return null
 
   return {
     ...item,
-    matchedIn: match[0],
-    snippet: extractSnippet(match[1], queryText, 40).slice(0, 140),
+    matchedIn: match.matchedIn,
+    snippet: extractSnippet(match.matchedValue, queryText, 40).slice(0, 140),
   }
 }
 
diff --git a/server/session-scanner/queue.ts b/server/session-scanner/queue.ts
index 4fd25852..11e8a42b 100644
--- a/server/session-scanner/queue.ts
+++ b/server/session-scanner/queue.ts
@@ -10,6 +10,7 @@ import type {
   SessionScanner,
   SessionScanResult,
   SessionRepairResult,
+  SessionRepairOptions,
 } from './types.js'
 import type { SessionCache } from './cache.js'
 
@@ -195,14 +196,19 @@ export class SessionRepairQueue extends EventEmitter {
           allowStaleMs: item.priority === 'active' ? ACTIVE_CACHE_GRACE_MS : undefined,
         })
         if (cached) {
-          const normalized = cached.sessionId === item.sessionId
-            ? cached
-            : { ...cached, sessionId: item.sessionId }
-          await this.postScan?.(normalized)
-          this.setProcessed(item.sessionId, normalized)
-          this.emit('scanned', normalized)
-          this.resolveWaiting(item.sessionId, normalized)
-          return
+          // For active priority: bypass cache if result has a resume issue that needs repair
+          if (item.priority === 'active' && cached.resumeIssue) {
+            // Fall through to scan/repair path below
+          } else {
+            const normalized = cached.sessionId === item.sessionId
+              ? cached
+              : { ...cached, sessionId: item.sessionId }
+            await this.postScan?.(normalized)
+            this.setProcessed(item.sessionId, normalized)
+            this.emit('scanned', normalized)
+            this.resolveWaiting(item.sessionId, normalized)
+            return
+          }
         }
 
         // Scan the session
@@ -213,9 +219,15 @@ export class SessionRepairQueue extends EventEmitter {
           : { ...scanResult, sessionId: item.sessionId }
         this.emit('scanned', normalizedScan)
 
-        // Repair if corrupted
-        if (normalizedScan.status === 'corrupted') {
-          const repairResult = await this.scanner.repair(item.filePath)
+        // Repair if corrupted, or if active priority and has resume issue
+        const needsRepair = normalizedScan.status === 'corrupted'
+          || (item.priority === 'active' && !!normalizedScan.resumeIssue)
+
+        if (needsRepair) {
+          const repairOptions: SessionRepairOptions = item.priority === 'active' && normalizedScan.resumeIssue
+            ? { includeResumeIssues: true }
+            : {}
+          const repairResult = await this.scanner.repair(item.filePath, repairOptions)
           this.emit('repaired', repairResult)
 
           // Re-scan to get updated result
@@ -382,6 +394,14 @@ export class SessionRepairQueue extends EventEmitter {
     return this.queuedBySessionId.has(sessionId) || this.processing.has(sessionId) || this.processed.has(sessionId)
   }
 
+  /**
+   * Remove a processed result so the session can be re-enqueued and re-awaited.
+   * Used by the service layer to force active-priority re-processing.
+   */
+  clearProcessed(sessionId: string): void {
+    this.processed.delete(sessionId)
+  }
+
   /**
    * Get the last processed result for a session, if any.
    */
diff --git a/server/session-scanner/scanner.ts b/server/session-scanner/scanner.ts
index f3b791b1..da29d586 100644
--- a/server/session-scanner/scanner.ts
+++ b/server/session-scanner/scanner.ts
@@ -11,6 +11,7 @@ import type {
   SessionScanner,
   SessionScanResult,
   SessionRepairResult,
+  SessionRepairOptions,
   ParsedMessage,
 } from './types.js'
 
@@ -39,6 +40,10 @@ function parseMessage(line: string, lineNumber: number): ParsedMessage | null {
       parentUuid: obj.parentUuid,
       type: obj.type,
       lineNumber,
+      subtype: obj.subtype,
+      toolUseID: obj.toolUseID,
+      dataType: obj.data?.type,
+      dataHookEvent: obj.data?.hookEvent,
     }
   } catch {
     return null
@@ -81,6 +86,65 @@ function findOrphans(
   )
 }
 
+/**
+ * Detect the inline stop-hook progress chain shape on the active leaf.
+ *
+ * The problematic shape is (from leaf toward root):
+ *   turn_duration? -> stop_hook_summary -> progress(hook_progress/Stop) -> assistant
+ *
+ * Where stop_hook_summary.parentUuid === progress.uuid
+ *   and stop_hook_summary.toolUseID === progress.toolUseID
+ *   and progress.dataType === 'hook_progress'
+ *   and progress.dataHookEvent === 'Stop'
+ *   and the progress is parented to an assistant message.
+ *
+ * Returns the matched nodes if found, or undefined.
+ */
+interface InlineProgressMatch {
+  stopSummary: ParsedMessage
+  progress: ParsedMessage
+  assistant: ParsedMessage
+}
+
+function detectInlineStopHookProgress(
+  lastMessage: ParsedMessage | undefined,
+  uuidToMessage: Map<string, ParsedMessage>,
+): InlineProgressMatch | undefined {
+  if (!lastMessage) return undefined
+
+  // The leaf may be turn_duration (skip it) or stop_hook_summary directly
+  let candidate = lastMessage
+  if (candidate.type === 'system' && candidate.subtype === 'turn_duration' && candidate.parentUuid) {
+    const parent = uuidToMessage.get(candidate.parentUuid)
+    if (parent) candidate = parent
+  }
+
+  // Candidate should be stop_hook_summary
+  if (candidate.type !== 'system' || candidate.subtype !== 'stop_hook_summary') return undefined
+  const stopSummary = candidate
+
+  // Parent of stop_hook_summary should be the progress record
+  if (!stopSummary.parentUuid) return undefined
+  const progress = uuidToMessage.get(stopSummary.parentUuid)
+  if (!progress) return undefined
+
+  // Validate progress record
+  if (progress.type !== 'progress') return undefined
+  if (progress.dataType !== 'hook_progress') return undefined
+  if (progress.dataHookEvent !== 'Stop') return undefined
+
+  // Validate toolUseID match
+  if (!stopSummary.toolUseID || stopSummary.toolUseID !== progress.toolUseID) return undefined
+
+  // Parent of progress should be an assistant message
+  if (!progress.parentUuid) return undefined
+  const assistant = uuidToMessage.get(progress.parentUuid)
+  if (!assistant) return undefined
+  if (assistant.type !== 'assistant') return undefined
+
+  return { stopSummary, progress, assistant }
+}
+
 /**
  * Create the session scanner implementation.
  */
@@ -137,6 +201,10 @@ export function createSessionScanner(): SessionScanner {
     const orphans = findOrphans(messages, uuidToMessage)
     const chainDepth = calculateChainDepth(messages, uuidToMessage)
 
+    // Detect resume issue on active chain (bounded: at most 3 parent hops from leaf)
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : undefined
+    const resumeMatch = detectInlineStopHookProgress(lastMessage, uuidToMessage)
+
     return {
       sessionId,
       filePath,
@@ -145,10 +213,11 @@ export function createSessionScanner(): SessionScanner {
       orphanCount: orphans.length,
       fileSize: stat.size,
       messageCount: messages.length,
+      resumeIssue: resumeMatch ? 'inline_stop_hook_progress' : undefined,
     }
   }
 
-  async function repair(filePath: string): Promise<SessionRepairResult> {
+  async function repair(filePath: string, options?: SessionRepairOptions): Promise<SessionRepairResult> {
     const sessionId = extractSessionId(filePath)
 
     // Read file
@@ -160,6 +229,7 @@ export function createSessionScanner(): SessionScanner {
         sessionId,
         status: 'failed',
         orphansFixed: 0,
+        resumeIssuesFixed: 0,
         newChainDepth: 0,
         error: `Failed to read file: ${err instanceof Error ? err.message : String(err)}`,
       }
@@ -184,6 +254,10 @@ export function createSessionScanner(): SessionScanner {
             parentUuid: obj.parentUuid,
             type: obj.type,
             lineNumber: i,
+            subtype: obj.subtype,
+            toolUseID: obj.toolUseID,
+            dataType: obj.data?.type,
+            dataHookEvent: obj.data?.hookEvent,
           }
           messages.push(msg)
           uuidToMessage.set(obj.uuid, msg)
@@ -196,12 +270,21 @@ export function createSessionScanner(): SessionScanner {
     // Find orphans
     const orphans = findOrphans(messages, uuidToMessage)
 
-    if (orphans.length === 0) {
+    // Detect inline-progress match when resume issue repair is enabled
+    const inlineMatch = options?.includeResumeIssues
+      ? detectInlineStopHookProgress(
+          messages.length > 0 ? messages[messages.length - 1] : undefined,
+          uuidToMessage,
+        )
+      : undefined
+
+    if (orphans.length === 0 && !inlineMatch) {
       const chainDepth = calculateChainDepth(messages, uuidToMessage)
       return {
         sessionId,
         status: 'already_healthy',
         orphansFixed: 0,
+        resumeIssuesFixed: 0,
         newChainDepth: chainDepth,
       }
     }
@@ -242,6 +325,17 @@ export function createSessionScanner(): SessionScanner {
       }
     }
 
+    // Fix inline stop-hook progress if detected
+    let resumeIssuesFixed = 0
+    if (inlineMatch) {
+      const obj = lineToObj.get(inlineMatch.stopSummary.lineNumber)
+      if (obj) {
+        obj.parentUuid = inlineMatch.assistant.uuid
+        fixedLines[inlineMatch.stopSummary.lineNumber] = JSON.stringify(obj)
+        resumeIssuesFixed = 1
+      }
+    }
+
     // Write repaired content
     await fs.writeFile(filePath, fixedLines.join('\n'))
 
@@ -266,6 +360,7 @@ export function createSessionScanner(): SessionScanner {
       status: 'repaired',
       backupPath,
       orphansFixed: orphans.length,
+      resumeIssuesFixed,
       newChainDepth,
     }
   }
diff --git a/server/session-scanner/service.ts b/server/session-scanner/service.ts
index 16cc78cd..38af37e2 100644
--- a/server/session-scanner/service.ts
+++ b/server/session-scanner/service.ts
@@ -156,6 +156,12 @@ export class SessionRepairService extends EventEmitter {
     // Check if already processed
     const existing = this.queue.getResult(sessionId)
     if (existing) {
+      // If the processed result has a resume issue, force active-priority repair
+      if (existing.resumeIssue) {
+        this.queue.clearProcessed(sessionId)
+        this.queue.enqueue([{ sessionId, filePath: existing.filePath, priority: 'active' }])
+        return this.queue.waitFor(sessionId, timeoutMs)
+      }
       await this.ensureSessionArtifacts(existing)
       return existing
     }
@@ -174,6 +180,18 @@ export class SessionRepairService extends EventEmitter {
     const fileSessionId = path.basename(filePath, '.jsonl')
     const legacyResult = this.queue.getResult(fileSessionId)
     if (legacyResult) {
+      // If the legacy result has a resume issue, force active-priority repair
+      if (legacyResult.resumeIssue) {
+        this.queue.clearProcessed(fileSessionId)
+        this.queue.enqueue([{ sessionId: fileSessionId, filePath, priority: 'active' }])
+        const result = await this.queue.waitFor(fileSessionId, timeoutMs)
+        const normalized = result.sessionId === sessionId
+          ? result
+          : { ...result, sessionId }
+        this.queue.seedResult(sessionId, normalized)
+        await this.ensureSessionArtifacts(normalized)
+        return normalized
+      }
       const normalized = legacyResult.sessionId === sessionId
         ? legacyResult
         : { ...legacyResult, sessionId }
@@ -199,6 +217,12 @@ export class SessionRepairService extends EventEmitter {
       if (cached.status === 'missing') {
         this.sessionPathIndex.delete(sessionId)
       }
+      // If cached result has a resume issue, force active-priority repair
+      if (cached.resumeIssue) {
+        this.queue.clearProcessed(sessionId)
+        this.queue.enqueue([{ sessionId, filePath, priority: 'active' }])
+        return this.queue.waitFor(sessionId, timeoutMs)
+      }
       const normalized = cached.sessionId === sessionId
         ? cached
         : { ...cached, sessionId }
diff --git a/server/session-scanner/types.ts b/server/session-scanner/types.ts
index 5388e9f9..991be07c 100644
--- a/server/session-scanner/types.ts
+++ b/server/session-scanner/types.ts
@@ -5,6 +5,12 @@
  * Node.js implementation first, same interface for Rust later.
  */
 
+/**
+ * Known resume issues that don't constitute corruption but prevent
+ * successful `--resume` in Claude CLI.
+ */
+export type SessionResumeIssue = 'inline_stop_hook_progress'
+
 /**
  * Result of scanning a session file for chain integrity.
  */
@@ -23,6 +29,16 @@ export interface SessionScanResult {
   fileSize: number
   /** Total number of messages in the file */
   messageCount: number
+  /** Resume issue detected on the active chain, if any */
+  resumeIssue?: SessionResumeIssue
+}
+
+/**
+ * Options for session repair.
+ */
+export interface SessionRepairOptions {
+  /** Also fix resume issues (not just orphans). Default: false. */
+  includeResumeIssues?: boolean
 }
 
 /**
@@ -37,6 +53,8 @@ export interface SessionRepairResult {
   backupPath?: string
   /** Number of orphan messages that were re-parented */
   orphansFixed: number
+  /** Number of resume issues that were fixed */
+  resumeIssuesFixed: number
   /** Chain depth after repair */
   newChainDepth: number
   /** Error message if failed */
@@ -57,7 +75,7 @@ export interface SessionScanner {
    * Repair a corrupted session file.
    * Creates backup before modifying. Idempotent - safe to call on healthy files.
    */
-  repair(filePath: string): Promise<SessionRepairResult>
+  repair(filePath: string, options?: SessionRepairOptions): Promise<SessionRepairResult>
 
   /**
    * Scan multiple files in parallel.
@@ -75,4 +93,12 @@ export interface ParsedMessage {
   parentUuid?: string
   type?: string
   lineNumber: number
+  /** System message subtype (e.g. 'stop_hook_summary', 'turn_duration') */
+  subtype?: string
+  /** Tool use ID for progress/hook records */
+  toolUseID?: string
+  /** data.type for progress records (e.g. 'hook_progress') */
+  dataType?: string
+  /** data.hookEvent for progress records (e.g. 'Stop') */
+  dataHookEvent?: string
 }
diff --git a/server/updater/version-checker.ts b/server/updater/version-checker.ts
index b8f931f4..95a8a177 100644
--- a/server/updater/version-checker.ts
+++ b/server/updater/version-checker.ts
@@ -73,6 +73,31 @@ export function isMinorOrMajorNewer(current: string, remote: string): boolean {
   return remoteMinor > currentMinor
 }
 
+type UpdateChecker = (currentVersion: string) => Promise<UpdateCheckResult>
+
+const DEFAULT_CACHE_TTL_MS = 10 * 60 * 1000 // 10 minutes
+
+export function createCachedUpdateChecker(
+  checker: UpdateChecker,
+  ttlMs: number = DEFAULT_CACHE_TTL_MS
+): UpdateChecker {
+  let cached: { result: UpdateCheckResult; expiresAt: number; version: string } | null = null
+
+  return async (currentVersion: string) => {
+    if (cached && cached.version === currentVersion && Date.now() < cached.expiresAt) {
+      return cached.result
+    }
+
+    const result = await checker(currentVersion)
+
+    if (!result.error) {
+      cached = { result, expiresAt: Date.now() + ttlMs, version: currentVersion }
+    }
+
+    return result
+  }
+}
+
 export async function checkForUpdate(currentVersion: string): Promise<UpdateCheckResult> {
   try {
     const response = await fetch(GITHUB_RELEASES_URL, {
diff --git a/server/ws-handler.ts b/server/ws-handler.ts
index d82ad3d1..d5c4037c 100644
--- a/server/ws-handler.ts
+++ b/server/ws-handler.ts
@@ -311,6 +311,7 @@ export class WsHandler {
   private terminalsRevision = 0
   private terminalRuntimeRevisions = new Map<string, number>()
   private readonly serverInstanceId: string
+  private readonly bootId: string
   // The runtime validator is authoritative here; we keep the field typed broadly because
   // the dynamic provider schemas widen discriminated-union inference beyond what TS/Zod model well.
   private clientMessageSchema: z.ZodTypeAny
@@ -352,6 +353,7 @@ export class WsHandler {
     this.serverInstanceId = serverInstanceId && serverInstanceId.trim().length > 0
       ? serverInstanceId
       : `srv-${randomUUID()}`
+    this.bootId = `boot-${randomUUID()}`
     this.terminalStreamBroker = new TerminalStreamBroker(this.registry)
 
     // Build the set of valid CLI provider/mode names from extensions
@@ -972,6 +974,16 @@ export class WsHandler {
       if (snapshot.configFallback) {
         this.safeSend(ws, { type: 'config.fallback', ...snapshot.configFallback })
       }
+
+      // Send terminal inventory so the client knows what's alive
+      const terminals = this.registry.list()
+      const terminalMeta = this.terminalMetaListProvider?.() ?? []
+      this.safeSend(ws, {
+        type: 'terminal.inventory',
+        bootId: this.bootId,
+        terminals,
+        terminalMeta,
+      })
     } catch (err) {
       logger.warn({ err }, 'Failed to send handshake snapshot')
     }
@@ -1072,6 +1084,7 @@ export class WsHandler {
           type: 'ready',
           timestamp: nowIso(),
           serverInstanceId: this.serverInstanceId,
+          bootId: this.bootId,
         })
         this.scheduleHandshakeSnapshot(ws, state)
         return
diff --git a/shared/session-title-search.ts b/shared/session-title-search.ts
new file mode 100644
index 00000000..55c1d645
--- /dev/null
+++ b/shared/session-title-search.ts
@@ -0,0 +1,57 @@
+export type TitleTierMetadata = {
+  title?: string
+  summary?: string
+  firstUserMessage?: string
+  cwd?: string
+  projectPath?: string
+}
+
+export type TitleTierMatch = {
+  matchedIn: 'title' | 'summary' | 'firstUserMessage'
+  matchedValue: string
+}
+
+function includesQuery(value: string | undefined, normalizedQuery: string): value is string {
+  return typeof value === 'string' && value.toLowerCase().includes(normalizedQuery)
+}
+
+export function getLeafDirectoryName(pathLike?: string): string | undefined {
+  if (typeof pathLike !== 'string') return undefined
+
+  const trimmed = pathLike.trim()
+  if (!trimmed) return undefined
+
+  const normalized = trimmed.replace(/[\\/]+/g, '/').replace(/\/+$/, '')
+  if (!normalized || /^[A-Za-z]:$/.test(normalized)) return undefined
+
+  const segments = normalized.split('/').filter(Boolean)
+  return segments.at(-1)
+}
+
+export function matchTitleTierMetadata(
+  metadata: TitleTierMetadata,
+  query: string,
+): TitleTierMatch | null {
+  const normalizedQuery = query.trim().toLowerCase()
+  if (!normalizedQuery) return null
+
+  const projectLeaf = getLeafDirectoryName(metadata.projectPath)
+  const cwdLeaf = getLeafDirectoryName(metadata.cwd)
+  const distinctCwdLeaf = cwdLeaf && cwdLeaf !== projectLeaf ? cwdLeaf : undefined
+
+  const searchable: Array<[TitleTierMatch['matchedIn'], string | undefined]> = [
+    ['title', metadata.title],
+    ['title', projectLeaf],
+    ['title', distinctCwdLeaf],
+    ['summary', metadata.summary],
+    ['firstUserMessage', metadata.firstUserMessage],
+  ]
+
+  const match = searchable.find(([, value]) => includesQuery(value, normalizedQuery))
+  if (!match || !match[1]) return null
+
+  return {
+    matchedIn: match[0],
+    matchedValue: match[1],
+  }
+}
diff --git a/shared/ws-protocol.ts b/shared/ws-protocol.ts
index 2015c566..fb0190b8 100644
--- a/shared/ws-protocol.ts
+++ b/shared/ws-protocol.ts
@@ -402,6 +402,7 @@ export type ReadyMessage = {
   type: 'ready'
   timestamp: string
   serverInstanceId?: string
+  bootId?: string
 }
 
 export type PongMessage = {
@@ -664,6 +665,23 @@ export type ExtensionServerStoppedMessage = {
   name: string
 }
 
+export type TerminalInventoryMessage = {
+  type: 'terminal.inventory'
+  bootId: string
+  terminals: Array<{
+    terminalId: string
+    title: string
+    description?: string
+    mode: string
+    resumeSessionId?: string
+    createdAt: number
+    lastActivityAt: number
+    status: 'running' | 'exited'
+    cwd?: string
+  }>
+  terminalMeta: TerminalMetaRecord[]
+}
+
 // ── Server message discriminated union ──
 
 export type ServerMessage =
@@ -681,6 +699,7 @@ export type ServerMessage =
   | TerminalsChangedMessage
   | TerminalRuntimeUpdatedMessage
   | TerminalMetaUpdatedMessage
+  | TerminalInventoryMessage
   | CodexActivityListResponseMessage
   | CodexActivityUpdatedMessage
   | SessionsChangedMessage
diff --git a/src/App.tsx b/src/App.tsx
index f6d21c92..6c60a049 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,6 +1,6 @@
 import { lazy, Suspense, useCallback, useEffect, useRef, useState, type TouchEvent as ReactTouchEvent } from 'react'
 import { useAppDispatch, useAppSelector, useAppStore } from '@/store/hooks'
-import { setStatus, setError, setErrorCode, setServerInstanceId, setPlatform, setAvailableClis, setFeatureFlags } from '@/store/connectionSlice'
+import { setStatus, setError, setErrorCode, setServerInstanceId, setBootId, setServerRestarted, setLiveTerminalIds, setPlatform, setAvailableClis, setFeatureFlags } from '@/store/connectionSlice'
 import { setLocalSettings, setServerSettings } from '@/store/settingsSlice'
 import {
   markWsSnapshotReceived,
@@ -54,7 +54,9 @@ import { triggerHapticFeedback } from '@/lib/mobile-haptics'
 import { X, Copy, Check, PanelLeft, AlertTriangle } from 'lucide-react'
 import { updateSettingsLocal } from '@/store/settingsSlice'
 
-import { upsertTerminalMeta, removeTerminalMeta } from '@/store/terminalMetaSlice'
+import { setTerminalMetaSnapshot, upsertTerminalMeta, removeTerminalMeta } from '@/store/terminalMetaSlice'
+import { clearDeadTerminals } from '@/store/panesSlice'
+import { addTerminalRestoreRequestId } from '@/lib/terminal-restore'
 import { setCodexActivitySnapshot, upsertCodexActivity, removeCodexActivity, resetCodexActivity } from '@/store/codexActivitySlice'
 import { setRegistry, updateServerStatus } from '@/store/extensionsSlice'
 import { handleSdkMessage } from '@/lib/sdk-message-handler'
@@ -136,6 +138,7 @@ const ReadyMessageSchema = z.object({
   type: z.literal('ready'),
   timestamp: z.string(),
   serverInstanceId: z.string().min(1),
+  bootId: z.string().min(1).optional(),
 })
 
 export default function App() {
@@ -446,6 +449,7 @@ export default function App() {
     let startupRecoveryRerunRequested = false
     let platformCapabilitiesLoaded = false
     let lastReadyServerInstanceId: string | undefined
+    let lastSessionsRevision = -1
     const versionInfoLoadedRef = { current: false }
 
     async function bootstrap() {
@@ -717,15 +721,28 @@ export default function App() {
           dispatch(setError(undefined))
           dispatch(setStatus('ready'))
           dispatch(setServerInstanceId(ready.success ? ready.data.serverInstanceId : undefined))
+          const newBootId = ready.success ? ready.data.bootId : undefined
+          const previousBootId = appStore.getState().connection.bootId
+          const serverRestarted = !!previousBootId && previousBootId !== newBootId
+          dispatch(setBootId(newBootId))
+          dispatch(setServerRestarted(serverRestarted))
+          if (serverRestarted) {
+            dispatch(setLiveTerminalIds([]))
+          }
           dispatch(resetWsSnapshotReceived())
           // If App registered late and missed a prior invalidation, a fresh HTTP baseline
           // from this bootstrap cycle is still safe for enabling follow-up refreshes.
           promoteRecentHttpSessionsBaseline()
           requestCodexActivityList()
+          lastSessionsRevision = -1
           void recoverMissingStartupState()
         }
         if (msg.type === 'sessions.changed') {
-          void appStore.dispatch(queueActiveSessionWindowRefresh() as any)
+          const rev = typeof msg.revision === 'number' ? msg.revision : -1
+          if (rev > lastSessionsRevision) {
+            lastSessionsRevision = rev
+            void appStore.dispatch(queueActiveSessionWindowRefresh() as any)
+          }
         }
         if (msg.type === 'settings.updated') {
           dispatch(setServerSettings(msg.settings as ServerSettings))
@@ -748,6 +765,35 @@ export default function App() {
             dispatch(removeTerminalMeta(terminalId))
           }
         }
+        if (msg.type === 'terminal.inventory') {
+          const terminals = Array.isArray(msg.terminals) ? msg.terminals : []
+          const terminalMeta = Array.isArray(msg.terminalMeta) ? msg.terminalMeta : []
+          const liveIds = terminals
+            .filter((t: any) => t.status === 'running')
+            .map((t: any) => t.terminalId as string)
+          dispatch(setLiveTerminalIds(liveIds))
+          dispatch(setServerRestarted(false))
+          dispatch(clearDeadTerminals({ liveTerminalIds: liveIds }))
+          // Register new createRequestIds with the restore set so the
+          // subsequent terminal.create messages include restore: true
+          // and bypass the server's rate limiter.
+          const layouts = appStore.getState().panes.layouts
+          for (const layout of Object.values(layouts)) {
+            ;(function walk(node: any) {
+              if (!node) return
+              if (node.type === 'leaf') {
+                if (node.content?.kind === 'terminal' && node.content.status === 'creating' && node.content.createRequestId) {
+                  addTerminalRestoreRequestId(node.content.createRequestId)
+                }
+                return
+              }
+              if (node.type === 'split' && Array.isArray(node.children)) {
+                for (const child of node.children) walk(child)
+              }
+            })(layout)
+          }
+          dispatch(setTerminalMetaSnapshot({ terminals: terminalMeta, requestedAt: Date.now() }))
+        }
         if (msg.type === 'codex.activity.list.response') {
           const requestId = typeof msg.requestId === 'string' ? msg.requestId : ''
           if (!requestId) return
diff --git a/src/components/Sidebar.tsx b/src/components/Sidebar.tsx
index 239ad382..577a0756 100644
--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
@@ -72,6 +72,7 @@ export function areSessionItemsEqual(a: SessionItem[], b: SessionItem[]): boolea
       ai.projectColor !== bi.projectColor ||
       ai.cwd !== bi.cwd ||
       ai.projectPath !== bi.projectPath ||
+      ai.isFallback !== bi.isFallback ||
       ai.timestamp !== bi.timestamp
     ) return false
   }
@@ -123,6 +124,7 @@ function isSessionItemEqual(a: SessionItem, b: SessionItem): boolean {
     a.projectColor === b.projectColor &&
     a.cwd === b.cwd &&
     a.projectPath === b.projectPath &&
+    a.isFallback === b.isFallback &&
     a.ratchetedActivity === b.ratchetedActivity &&
     a.hasTitle === b.hasTitle &&
     a.isSubagent === b.isSubagent &&
@@ -197,14 +199,23 @@ export default function Sidebar({
   const terminals = useAppSelector((state) => (
     (state as any).terminalDirectory?.windows?.sidebar?.items ?? EMPTY_TERMINALS
   )) as BackgroundTerminal[]
-  const [filter, setFilter] = useState('')
-  const [searchTier, setSearchTier] = useState<'title' | 'userMessages' | 'fullText'>('title')
   const lastMarkedSearchQueryRef = useRef<string | null>(null)
   const wasSearchingRef = useRef(false)
+  const hasInitializedSearchEffectRef = useRef(false)
   const listRef = useRef<HTMLDivElement | null>(null)
   const listContentRef = useRef<HTMLDivElement | null>(null)
   const listMetricsRef = useRef({ clientHeight: 0, scrollHeight: 0 })
 
+  const requestedQueryValue = sidebarWindow?.query ?? ''
+  const requestedQuery = requestedQueryValue.trim()
+  const requestedSearchTier = sidebarWindow?.searchTier ?? 'title'
+  const appliedQuery = (sidebarWindow?.appliedQuery ?? '').trim()
+  const appliedSearchTier = sidebarWindow?.appliedSearchTier ?? 'title'
+  const [filter, setFilter] = useState(requestedQueryValue)
+  const [searchTier, setSearchTier] = useState<typeof requestedSearchTier>(requestedSearchTier)
+  const localQuery = filter.trim()
+  const localMatchesRequestedSearch = filter === requestedQueryValue && searchTier === requestedSearchTier
+
   // Tick counter that increments every 15s to keep relative timestamps fresh.
   // The custom comparator on SidebarItem ensures only the timestamp text node
   // updates — no DOM flicker despite the frequent ticks.
@@ -215,8 +226,42 @@ export default function Sidebar({
   }, [])
 
   useEffect(() => {
-    const query = filter.trim()
-    if (!query) {
+    setFilter(requestedQueryValue)
+  }, [requestedQueryValue])
+
+  useEffect(() => {
+    setSearchTier(requestedSearchTier)
+  }, [requestedSearchTier])
+
+  useEffect(() => {
+    let shouldDispatchInitialRequestedSearch = false
+
+    if (!hasInitializedSearchEffectRef.current) {
+      const currentSidebarWindow = store.getState().sessions.windows?.sidebar
+      const currentRequestedQuery = (currentSidebarWindow?.query ?? '').trim()
+      const currentRequestedSearchTier = currentSidebarWindow?.searchTier ?? 'title'
+      const currentAppliedQuery = (currentSidebarWindow?.appliedQuery ?? '').trim()
+      const currentAppliedSearchTier = currentSidebarWindow?.appliedSearchTier ?? 'title'
+      shouldDispatchInitialRequestedSearch = localMatchesRequestedSearch
+        && currentRequestedQuery.length > 0
+        && (
+          currentRequestedQuery !== currentAppliedQuery
+          || currentRequestedSearchTier !== currentAppliedSearchTier
+          || typeof currentSidebarWindow?.lastLoadedAt !== 'number'
+        )
+
+      hasInitializedSearchEffectRef.current = true
+      wasSearchingRef.current = currentRequestedQuery.length > 0 || currentAppliedQuery.length > 0
+      if (!shouldDispatchInitialRequestedSearch) {
+        return
+      }
+    }
+
+    if (localMatchesRequestedSearch && !shouldDispatchInitialRequestedSearch) {
+      return
+    }
+
+    if (!localQuery) {
       if (wasSearchingRef.current) {
         wasSearchingRef.current = false
         lastMarkedSearchQueryRef.current = null
@@ -233,7 +278,7 @@ export default function Sidebar({
       void dispatch(fetchSessionWindow({
         surface: 'sidebar',
         priority: 'visible',
-        query,
+        query: localQuery,
         searchTier,
       }) as any)
     }, 300) // Debounce 300ms
@@ -241,7 +286,13 @@ export default function Sidebar({
     return () => {
       clearTimeout(timeoutId)
     }
-  }, [dispatch, filter, searchTier])
+  }, [
+    dispatch,
+    localMatchesRequestedSearch,
+    localQuery,
+    searchTier,
+    store,
+  ])
 
   const localFilteredItems = useAppSelector((state) => selectSortedItems(state, terminals, ''))
   const computedItems = useMemo(() => localFilteredItems, [localFilteredItems])
@@ -373,30 +424,31 @@ export default function Sidebar({
   const activeTab = tabs.find((t) => t.id === activeTabId)
   const activeSessionKey = activeSessionKeyFromPanes
   const activeTerminalId = activeTab?.terminalId
-  const activeSearchTier = sidebarWindow?.searchTier ?? searchTier
   const hasLoadedSidebarWindow = typeof sidebarWindow?.lastLoadedAt === 'number'
   const sidebarWindowHasItems = (sidebarWindow?.projects ?? []).some((project) => (project.sessions?.length ?? 0) > 0)
-  const activeQuery = (sidebarWindow?.query ?? filter).trim()
+  const visibleQuery = appliedQuery || requestedQuery
+  const visibleSearchTier = appliedQuery ? appliedSearchTier : requestedSearchTier
   const loadingKind = sidebarWindow?.loadingKind
+  const hasRequestedQuery = requestedQuery.length > 0
   const showBlockingLoad = !!sidebarWindow?.loading
     && loadingKind === 'initial'
     && !hasLoadedSidebarWindow
     && !sidebarWindowHasItems
-  const showSearchLoading = !!sidebarWindow?.loading && loadingKind === 'search'
+  const showSearchLoading = !!sidebarWindow?.loading
+    && loadingKind === 'search'
+    && hasRequestedQuery
   const showDeepSearchPending = !!sidebarWindow?.deepSearchPending
   const sidebarHasMore = sidebarWindow?.hasMore ?? false
   const sidebarOldestLoadedTimestamp = sidebarWindow?.oldestLoadedTimestamp
   const sidebarOldestLoadedSessionId = sidebarWindow?.oldestLoadedSessionId
-  const localQuery = filter.trim()
-  const committedQuery = (sidebarWindow?.query ?? '').trim()
-  const hasActiveQuery = localQuery.length > 0 || committedQuery.length > 0
+  const hasAppliedQuery = appliedQuery.length > 0
 
   const loadMoreInFlightRef = useRef(false)
   const loadMoreTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
   const requestSidebarAppend = useCallback(() => {
     if (!sidebarHasMore || sidebarWindow?.loading || loadMoreInFlightRef.current) return
     if (sidebarOldestLoadedTimestamp == null || sidebarOldestLoadedSessionId == null) return
-    if (hasActiveQuery) return
+    if (hasAppliedQuery) return
 
     loadMoreInFlightRef.current = true
     void dispatch(fetchSessionWindow({
@@ -410,7 +462,7 @@ export default function Sidebar({
     }, 15_000)
   }, [
     dispatch,
-    hasActiveQuery,
+    hasAppliedQuery,
     sidebarHasMore,
     sidebarOldestLoadedSessionId,
     sidebarOldestLoadedTimestamp,
@@ -491,17 +543,16 @@ export default function Sidebar({
   }, [])
 
   useEffect(() => {
-    const query = filter.trim()
-    if (!query) return
+    if (!requestedQuery) return
     if (sidebarWindow?.loading) return
     if (sortedItems.length === 0) return
-    if (lastMarkedSearchQueryRef.current === query) return
+    if (lastMarkedSearchQueryRef.current === requestedQuery) return
     getInstalledPerfAuditBridge()?.mark('sidebar.search_results_visible', {
-      query,
+      query: requestedQuery,
       resultCount: sortedItems.length,
     })
-    lastMarkedSearchQueryRef.current = query
-  }, [filter, sidebarWindow?.loading, sortedItems.length])
+    lastMarkedSearchQueryRef.current = requestedQuery
+  }, [requestedQuery, sidebarWindow?.loading, sortedItems.length])
 
   return (
     <div
@@ -599,12 +650,12 @@ export default function Sidebar({
             ) : null}
           </div>
         </div>
-        {filter.trim() && (
+        {localQuery && (
           <div className="mt-2">
             <select
               aria-label="Search tier"
               value={searchTier}
-              onChange={(e) => setSearchTier(e.target.value as typeof searchTier)}
+              onChange={(e) => setSearchTier(e.target.value as typeof requestedSearchTier)}
               className="w-full h-7 px-2 text-xs bg-muted/50 border-0 rounded-md focus:outline-none focus:ring-1 focus:ring-border"
             >
               <option value="title">Title</option>
@@ -652,11 +703,11 @@ export default function Sidebar({
           {showBlockingLoad ? (
             <div
               className="flex items-center justify-center py-8"
-              data-testid={activeQuery ? 'search-loading' : undefined}
+              data-testid={hasRequestedQuery ? 'search-loading' : undefined}
             >
               <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
               <span className="ml-2 text-sm text-muted-foreground">
-                {activeQuery ? 'Searching...' : 'Loading sessions...'}
+                {hasRequestedQuery ? 'Searching...' : 'Loading sessions...'}
               </span>
             </div>
           ) : sortedItems.length === 0 ? (
@@ -667,9 +718,9 @@ export default function Sidebar({
             </div>
           ) : (
           <div className="px-2 py-8 text-center text-sm text-muted-foreground">
-            {activeQuery && activeSearchTier !== 'title'
+            {visibleQuery && visibleSearchTier !== 'title'
               ? 'No results found'
-              : activeQuery
+              : visibleQuery
               ? 'No matching sessions'
               : 'No sessions yet'}
           </div>
@@ -750,7 +801,8 @@ function areSidebarItemPropsEqual(prev: SidebarItemProps, next: SidebarItemProps
     a.archived === b.archived &&
     a.projectColor === b.projectColor &&
     a.cwd === b.cwd &&
-    a.projectPath === b.projectPath
+    a.projectPath === b.projectPath &&
+    a.isFallback === b.isFallback
   )
 }
 
diff --git a/src/components/TerminalView.tsx b/src/components/TerminalView.tsx
index 7c5187d3..03e22da6 100644
--- a/src/components/TerminalView.tsx
+++ b/src/components/TerminalView.tsx
@@ -38,6 +38,8 @@ import {
 } from '@/lib/terminal-attach-seq-state'
 import { useMobile } from '@/hooks/useMobile'
 import { findLocalFilePaths } from '@/lib/path-utils'
+import { findUrls } from '@/lib/url-utils'
+import { setHoveredUrl, clearHoveredUrl } from '@/lib/terminal-hovered-url'
 import { getTabSwitchShortcutDirection, getTabLifecycleAction } from '@/lib/tab-switch-shortcuts'
 import {
   createTurnCompleteSignalParserState,
@@ -66,16 +68,16 @@ import { cn } from '@/lib/utils'
 import { Terminal } from '@xterm/xterm'
 import { Loader2 } from 'lucide-react'
 import { ConfirmModal } from '@/components/ui/confirm-modal'
-import type { PaneContent, PaneRefreshRequest, TerminalPaneContent } from '@/store/paneTypes'
+import type { PaneContent, PaneContentInput, PaneRefreshRequest, TerminalPaneContent } from '@/store/paneTypes'
 import '@xterm/xterm/css/xterm.css'
 import { createLogger } from '@/lib/client-logger'
 
 const log = createLogger('TerminalView')
 
 const SESSION_ACTIVITY_THROTTLE_MS = 5000
-const RATE_LIMIT_RETRY_MAX_ATTEMPTS = 3
-const RATE_LIMIT_RETRY_BASE_MS = 250
-const RATE_LIMIT_RETRY_MAX_MS = 1000
+export const RATE_LIMIT_RETRY_MAX_ATTEMPTS = 5
+export const RATE_LIMIT_RETRY_BASE_MS = 2000
+export const RATE_LIMIT_RETRY_MAX_MS = 12000
 const KEYBOARD_INSET_ACTIVATION_PX = 80
 const MOBILE_KEYBAR_HEIGHT_PX = 40
 const MOBILE_KEY_REPEAT_INITIAL_DELAY_MS = 320
@@ -95,6 +97,13 @@ function resolveMinimumContrastRatio(theme?: { isDark?: boolean } | null): numbe
   return theme?.isDark === false ? LIGHT_THEME_MIN_CONTRAST_RATIO : DEFAULT_MIN_CONTRAST_RATIO
 }
 
+function deferTerminalPointerMutation(callback: () => void): void {
+  // xterm link activation runs inside element-level mouse handlers while it may
+  // still have document-level mouseup/move listeners in flight. Reparenting the
+  // terminal synchronously can dispose the renderer before those listeners finish.
+  queueMicrotask(callback)
+}
+
 function createNoopRuntime(): TerminalRuntime {
   return {
     attachAddons: () => {},
@@ -218,6 +227,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
   const suppressNetworkEffects = typeof window !== 'undefined'
     && window.__FRESHELL_TEST_HARNESS__?.isTerminalNetworkEffectsSuppressed?.(paneId) === true
   const [isAttaching, setIsAttaching] = useState(false)
+  const wasCreatedFreshRef = useRef(paneContent.kind === 'terminal' && paneContent.status === 'creating')
   const [pendingLinkUri, setPendingLinkUri] = useState<string | null>(null)
   const [pendingOsc52Event, setPendingOsc52Event] = useState<Osc52Event | null>(null)
   const [searchOpen, setSearchOpen] = useState(false)
@@ -228,6 +238,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
   const mobileCtrlActiveRef = useRef(false)
 
   const containerRef = useRef<HTMLDivElement | null>(null)
+  const wrapperRef = useRef<HTMLDivElement | null>(null)
   const termRef = useRef<Terminal | null>(null)
   const runtimeRef = useRef<TerminalRuntime | null>(null)
   const writeQueueRef = useRef<TerminalWriteQueue | null>(null)
@@ -402,7 +413,13 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
 
   useEffect(() => {
     hiddenRef.current = hidden
-  }, [hidden])
+    if (hidden) {
+      clearHoveredUrl(paneId)
+      if (wrapperRef.current) {
+        delete wrapperRef.current.dataset.hoveredUrl
+      }
+    }
+  }, [hidden, paneId])
 
   useEffect(() => {
     warnExternalLinksRef.current = settings.terminal.warnExternalLinks
@@ -965,6 +982,17 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
     event.stopPropagation()
   }, [])
 
+  const queuePaneSplit = useCallback((newContent: PaneContentInput) => {
+    deferTerminalPointerMutation(() => {
+      dispatch(splitPane({
+        tabId,
+        paneId,
+        direction: 'horizontal',
+        newContent,
+      }))
+    })
+  }, [dispatch, paneId, tabId])
+
   useEffect(() => {
     return () => {
       clearMobileToolbarRepeat()
@@ -997,11 +1025,27 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
       theme: resolvedTheme,
       minimumContrastRatio: resolveMinimumContrastRatio(resolvedTheme),
       linkHandler: {
-        activate: (_event: MouseEvent, uri: string) => {
+        activate: (event: MouseEvent, uri: string) => {
+          if (event.button !== 0) return
+          // Only open http/https URLs. Block javascript:, data:, and other
+          // potentially dangerous schemes from OSC 8 links.
+          if (!/^https?:\/\//i.test(uri)) return
           if (warnExternalLinksRef.current !== false) {
             setPendingLinkUriRef.current(uri)
           } else {
-            window.open(uri, '_blank', 'noopener,noreferrer')
+            queuePaneSplit({ kind: 'browser', url: uri, devToolsOpen: false })
+          }
+        },
+        hover: (_event: MouseEvent, text: string, _range: import('@xterm/xterm').IBufferRange) => {
+          setHoveredUrl(paneId, text)
+          if (wrapperRef.current) {
+            wrapperRef.current.dataset.hoveredUrl = text
+          }
+        },
+        leave: () => {
+          clearHoveredUrl(paneId)
+          if (wrapperRef.current) {
+            delete wrapperRef.current.dataset.hoveredUrl
           }
         },
       },
@@ -1054,20 +1098,56 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
               end: { x: m.endIndex, y: bufferLineNumber },
             },
             text: m.path,
-            activate: () => {
-              dispatch(splitPane({
-                tabId,
-                paneId,
-                direction: 'horizontal',
-                newContent: {
-                  kind: 'editor',
-                  filePath: m.path,
-                  language: null,
-                  readOnly: false,
-                  content: '',
-                  viewMode: 'source',
-                },
-              }))
+            activate: (event: MouseEvent) => {
+              if (event && event.button !== 0) return
+              queuePaneSplit({
+                kind: 'editor',
+                filePath: m.path,
+                language: null,
+                readOnly: false,
+                content: '',
+                viewMode: 'source',
+              })
+            },
+          })))
+        },
+      })
+      : { dispose: () => {} }
+
+    // Register custom link provider for clickable URLs in terminal output
+    const urlLinkDisposable = typeof term.registerLinkProvider === 'function'
+      ? term.registerLinkProvider({
+        provideLinks(bufferLineNumber: number, callback: (links: import('@xterm/xterm').ILink[] | undefined) => void) {
+          const bufferLine = term.buffer.active.getLine(bufferLineNumber - 1)
+          if (!bufferLine) { callback(undefined); return }
+          const text = bufferLine.translateToString()
+          const urls = findUrls(text)
+          if (urls.length === 0) { callback(undefined); return }
+          callback(urls.map((m) => ({
+            range: {
+              start: { x: m.startIndex + 1, y: bufferLineNumber },
+              end: { x: m.endIndex, y: bufferLineNumber },
+            },
+            text: m.url,
+            activate: (event: MouseEvent) => {
+              if (event && event.button !== 0) return
+              if (warnExternalLinksRef.current !== false) {
+                setPendingLinkUriRef.current(m.url)
+              } else {
+                queuePaneSplit({ kind: 'browser', url: m.url, devToolsOpen: false })
+              }
+            },
+            hover: () => {
+              setHoveredUrl(paneId, m.url)
+              if (wrapperRef.current) {
+                wrapperRef.current.dataset.hoveredUrl = m.url
+              }
+            },
+            leave: () => {
+              clearHoveredUrl(paneId)
+              if (wrapperRef.current) {
+                delete wrapperRef.current.dataset.hoveredUrl
+              }
             },
           })))
         },
@@ -1193,9 +1273,15 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
     })
     ro.observe(containerRef.current)
 
+    const wrapperEl = wrapperRef.current
     return () => {
       requestModeBypass.dispose()
       filePathLinkDisposable?.dispose()
+      urlLinkDisposable?.dispose()
+      clearHoveredUrl(paneId)
+      if (wrapperEl) {
+        delete wrapperEl.dataset.hoveredUrl
+      }
       ro.disconnect()
       unregisterActions()
       unregisterCaptureHandler()
@@ -1277,6 +1363,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
   }, [isTerminal, dispatch, tabId])
 
   const markAttachComplete = useCallback(() => {
+    wasCreatedFreshRef.current = false
     deferredAttachStateRef.current = {
       mode: 'live',
       pendingIntent: null,
@@ -1522,7 +1609,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
         if (requestIdRef.current !== requestId) return
         sendCreate(requestId)
       }, delayMs)
-      term.writeln(`\r\n[Rate limited - retrying in ${delayMs}ms]\r\n`)
+      term.writeln(`\r\n[Rate limited - retrying in ${(delayMs / 1000).toFixed(0)}s]\r\n`)
       return true
     }
 
@@ -1992,13 +2079,14 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
   const hasFatalConnectionError = isFatalConnectionErrorCode(connectionErrorCode)
   const showBlockingSpinner = terminalContent.status === 'creating' && !hasFatalConnectionError
   const showInlineOfflineStatus = connectionStatus !== 'ready' && !hasFatalConnectionError
-  const showInlineRecoveringStatus = connectionStatus === 'ready' && isAttaching && terminalContent.status !== 'creating'
+  const showInlineRecoveringStatus = connectionStatus === 'ready' && isAttaching && terminalContent.status !== 'creating' && !wasCreatedFreshRef.current
   const inlineStatusMessage = showInlineOfflineStatus
     ? 'Offline: input will queue until reconnected.'
     : (showInlineRecoveringStatus ? 'Recovering terminal output...' : null)
 
   return (
     <div
+      ref={wrapperRef}
       className={cn('h-full w-full', hidden ? 'tab-hidden' : 'tab-visible relative')}
       data-context={ContextIds.Terminal}
       data-pane-id={paneId}
@@ -2118,7 +2206,12 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter
         confirmLabel="Open link"
         onConfirm={() => {
           if (pendingLinkUri) {
-            window.open(pendingLinkUri, '_blank', 'noopener,noreferrer')
+            dispatch(splitPane({
+              tabId,
+              paneId,
+              direction: 'horizontal',
+              newContent: { kind: 'browser', url: pendingLinkUri, devToolsOpen: false },
+            }))
           }
           setPendingLinkUri(null)
         }}
diff --git a/src/components/context-menu/ContextMenuProvider.tsx b/src/components/context-menu/ContextMenuProvider.tsx
index b1faa172..e809baa9 100644
--- a/src/components/context-menu/ContextMenuProvider.tsx
+++ b/src/components/context-menu/ContextMenuProvider.tsx
@@ -883,6 +883,29 @@ export function ContextMenuProvider({
     return cleanup
   }, [view, closeMenu, menuState])
 
+  const openUrlInPane = useCallback((tabId: string, paneId: string, url: string) => {
+    dispatch(splitPaneAction({
+      tabId,
+      paneId,
+      direction: 'horizontal',
+      newContent: { kind: 'browser', url, devToolsOpen: false },
+    }))
+  }, [dispatch])
+
+  const openUrlInTab = useCallback((url: string) => {
+    const id = nanoid()
+    dispatch(addTab({ id, mode: 'shell' }))
+    dispatch(initLayout({ tabId: id, content: { kind: 'browser', url, devToolsOpen: false } }))
+  }, [dispatch])
+
+  const openUrlInBrowser = useCallback((url: string) => {
+    window.open(url, '_blank', 'noopener,noreferrer')
+  }, [])
+
+  const copyUrlAction = useCallback(async (url: string) => {
+    await copyText(url)
+  }, [])
+
   const menuItems = useMemo(() => {
     if (!menuState) return []
     return buildMenuItems(menuState.target, {
@@ -960,6 +983,10 @@ export function ContextMenuProvider({
         copyAgentChatDiffNew: copyAgentChatDiffNew,
         copyAgentChatDiffOld: copyAgentChatDiffOld,
         copyAgentChatFilePath: copyAgentChatFilePath,
+        openUrlInPane,
+        openUrlInTab,
+        openUrlInBrowser,
+        copyUrl: copyUrlAction,
       },
     })
   }, [
@@ -1016,6 +1043,10 @@ export function ContextMenuProvider({
     copyTerminalCwd,
     copyMessageText,
     copyMessageCode,
+    openUrlInPane,
+    openUrlInTab,
+    openUrlInBrowser,
+    copyUrlAction,
   ])
 
   return (
diff --git a/src/components/context-menu/context-menu-types.ts b/src/components/context-menu/context-menu-types.ts
index da8453a9..b115ddbd 100644
--- a/src/components/context-menu/context-menu-types.ts
+++ b/src/components/context-menu/context-menu-types.ts
@@ -7,7 +7,7 @@ export type ContextTarget =
   | { kind: 'tab-add' }
   | { kind: 'pane'; tabId: string; paneId: string }
   | { kind: 'pane-divider'; tabId: string; splitId: string }
-  | { kind: 'terminal'; tabId: string; paneId: string }
+  | { kind: 'terminal'; tabId: string; paneId: string; hoveredUrl?: string }
   | { kind: 'browser'; tabId: string; paneId: string }
   | { kind: 'editor'; tabId: string; paneId: string }
   | { kind: 'pane-picker'; tabId: string; paneId: string }
diff --git a/src/components/context-menu/context-menu-utils.ts b/src/components/context-menu/context-menu-utils.ts
index 737de516..53ffcc74 100644
--- a/src/components/context-menu/context-menu-utils.ts
+++ b/src/components/context-menu/context-menu-utils.ts
@@ -46,7 +46,12 @@ export function parseContextTarget(contextId: ContextId, data: ContextDataset):
         : null
     case ContextIds.Terminal:
       return data.tabId && data.paneId
-        ? { kind: 'terminal', tabId: data.tabId, paneId: data.paneId }
+        ? {
+            kind: 'terminal',
+            tabId: data.tabId,
+            paneId: data.paneId,
+            hoveredUrl: data.hoveredUrl,
+          }
         : null
     case ContextIds.Browser:
       return data.tabId && data.paneId
diff --git a/src/components/context-menu/menu-defs.ts b/src/components/context-menu/menu-defs.ts
index 685d833a..ecc4cdff 100644
--- a/src/components/context-menu/menu-defs.ts
+++ b/src/components/context-menu/menu-defs.ts
@@ -64,6 +64,10 @@ export type MenuActions = {
   copyAgentChatDiffOld: (clickTarget: HTMLElement | null) => void
   copyAgentChatFilePath: (clickTarget: HTMLElement | null) => void
   showKeyboardShortcuts: () => void
+  openUrlInPane: (tabId: string, paneId: string, url: string) => void
+  openUrlInTab: (url: string) => void
+  openUrlInBrowser: (url: string) => void
+  copyUrl: (url: string) => void
 }
 
 export type MenuBuildContext = {
@@ -338,7 +342,37 @@ export function buildMenuItems(target: ContextTarget, ctx: MenuBuildContext): Me
       ? [buildCopyResumeMenuItem('terminal-copy-resume-command', resumeCandidate, actions, extensions)]
       : []
     const canRefreshPane = !!paneContent && !!buildPaneRefreshTarget(paneContent)
+
+    const urlItems: MenuItem[] = target.hoveredUrl ? [
+      {
+        type: 'item',
+        id: 'url-open-pane',
+        label: 'Open URL in pane',
+        onSelect: () => actions.openUrlInPane(target.tabId, target.paneId, target.hoveredUrl!),
+      },
+      {
+        type: 'item',
+        id: 'url-open-tab',
+        label: 'Open URL in new tab',
+        onSelect: () => actions.openUrlInTab(target.hoveredUrl!),
+      },
+      {
+        type: 'item',
+        id: 'url-open-browser',
+        label: 'Open in external browser',
+        onSelect: () => actions.openUrlInBrowser(target.hoveredUrl!),
+      },
+      {
+        type: 'item',
+        id: 'url-copy',
+        label: 'Copy URL',
+        onSelect: () => actions.copyUrl(target.hoveredUrl!),
+      },
+      { type: 'separator', id: 'url-sep' },
+    ] : []
+
     return [
+      ...urlItems,
       ...buildTerminalClipboardItems(terminalActions, hasSelection),
       { type: 'separator', id: 'terminal-clipboard-sep' },
       {
diff --git a/src/lib/terminal-hovered-url.ts b/src/lib/terminal-hovered-url.ts
new file mode 100644
index 00000000..04558155
--- /dev/null
+++ b/src/lib/terminal-hovered-url.ts
@@ -0,0 +1,15 @@
+// Tracks which URL is currently hovered per terminal pane for context menus.
+
+const hoveredUrls = new Map<string, string>()
+
+export function setHoveredUrl(paneId: string, url: string): void {
+  hoveredUrls.set(paneId, url)
+}
+
+export function clearHoveredUrl(paneId: string): void {
+  hoveredUrls.delete(paneId)
+}
+
+export function getHoveredUrl(paneId: string): string | undefined {
+  return hoveredUrls.get(paneId)
+}
diff --git a/src/lib/url-utils.ts b/src/lib/url-utils.ts
new file mode 100644
index 00000000..079a760c
--- /dev/null
+++ b/src/lib/url-utils.ts
@@ -0,0 +1,50 @@
+// Detects http/https URLs in terminal output text with balanced-paren handling.
+
+export type UrlMatch = {
+  url: string
+  startIndex: number
+  endIndex: number
+}
+
+export function findUrls(line: string): UrlMatch[] {
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g
+  const results: UrlMatch[] = []
+  let match
+  while ((match = urlRegex.exec(line)) !== null) {
+    let url = match[0]
+    // Trim trailing punctuation that's likely not part of the URL.
+    // Preserve balanced parentheses (e.g. Wikipedia URLs like
+    // https://en.wikipedia.org/wiki/Foo_(bar) ).
+    const trailingPunct = /[.,;:!?)]+$/
+    const trailingMatch = trailingPunct.exec(url)
+    if (trailingMatch) {
+      let trimmed = trailingMatch[0]
+      // Walk backwards through the trailing punctuation. For each
+      // closing paren, keep it if the URL body has a matching open
+      // paren; otherwise strip it along with everything after it.
+      let keep = ''
+      for (let i = 0; i < trimmed.length; i++) {
+        if (trimmed[i] === ')') {
+          // Count parens in the URL prefix (before the trailing chunk)
+          // plus any trailing chars we've already decided to keep.
+          const prefix = url.slice(0, url.length - trimmed.length) + keep
+          const opens = prefix.split('(').length - 1
+          const closes = prefix.split(')').length - 1
+          if (opens > closes) {
+            keep += trimmed[i]
+            continue
+          }
+        }
+        // Non-paren trailing punct or unbalanced paren: strip from here
+        break
+      }
+      url = url.slice(0, url.length - trimmed.length) + keep
+    }
+    results.push({
+      url,
+      startIndex: match.index,
+      endIndex: match.index + url.length,
+    })
+  }
+  return results
+}
diff --git a/src/lib/ws-client.ts b/src/lib/ws-client.ts
index efef85f5..08b2cd5b 100644
--- a/src/lib/ws-client.ts
+++ b/src/lib/ws-client.ts
@@ -95,7 +95,10 @@ export class WsClient {
   private reconnectAttempts = 0
   private maxReconnectAttempts = 10
   private baseReconnectDelay = 1000
+  private maxReconnectDelay = 4000
+  private postShutdownBaseDelay = 500
   private wasConnectedOnce = false
+  private fastReconnectMode = false
 
   private maxQueueSize = 1000
   private connectStartedAt: number | null = null
@@ -176,6 +179,7 @@ export class WsClient {
       this.ws.onopen = () => {
         this._state = 'connected'
         this.reconnectAttempts = 0
+        this.fastReconnectMode = false
 
         // Send hello with token in message body (not URL).
         const token = getAuthToken()
@@ -368,8 +372,9 @@ export class WsClient {
 
         if (event.code === 4009) {
           // SERVER_SHUTDOWN — server is rebinding and will be back shortly.
-          // Reset backoff for a fast ~1s reconnect.
+          // Reset backoff and use faster base delay for quick recovery.
           this.reconnectAttempts = 0
+          this.fastReconnectMode = true
           finishReject(new Error('Server restarting (rebind)'))
           this.scheduleReconnect()
           return
@@ -410,8 +415,11 @@ export class WsClient {
       return
     }
 
-    const baseDelay = this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts)
-    const delay = Math.max(baseDelay, opts?.minDelayMs ?? 0)
+    const base = this.fastReconnectMode ? this.postShutdownBaseDelay : this.baseReconnectDelay
+    const exponential = base * Math.pow(2, this.reconnectAttempts)
+    const capped = Math.min(exponential, this.maxReconnectDelay)
+    const jitter = capped * (0.8 + Math.random() * 0.4)
+    const delay = Math.max(Math.round(jitter), opts?.minDelayMs ?? 0)
     this.reconnectAttempts++
 
     this.clearReconnectTimer()
diff --git a/src/store/connectionSlice.ts b/src/store/connectionSlice.ts
index e1110c6b..8c7b332d 100644
--- a/src/store/connectionSlice.ts
+++ b/src/store/connectionSlice.ts
@@ -8,6 +8,9 @@ export interface ConnectionState {
   lastErrorCode?: number
   lastReadyAt?: number
   serverInstanceId?: string
+  bootId?: string
+  serverRestarted?: boolean
+  liveTerminalIds?: string[]
   platform: string | null
   availableClis: Record<string, boolean>
   featureFlags: Record<string, boolean>
@@ -47,6 +50,15 @@ export const connectionSlice = createSlice({
     setServerInstanceId: (state, action: PayloadAction<string | undefined>) => {
       state.serverInstanceId = action.payload
     },
+    setBootId: (state, action: PayloadAction<string | undefined>) => {
+      state.bootId = action.payload
+    },
+    setServerRestarted: (state, action: PayloadAction<boolean>) => {
+      state.serverRestarted = action.payload
+    },
+    setLiveTerminalIds: (state, action: PayloadAction<string[] | undefined>) => {
+      state.liveTerminalIds = action.payload
+    },
     setPlatform: (state, action: PayloadAction<string>) => {
       state.platform = action.payload
     },
@@ -59,5 +71,5 @@ export const connectionSlice = createSlice({
   },
 })
 
-export const { setStatus, setError, setErrorCode, setServerInstanceId, setPlatform, setAvailableClis, setFeatureFlags } = connectionSlice.actions
+export const { setStatus, setError, setErrorCode, setServerInstanceId, setBootId, setServerRestarted, setLiveTerminalIds, setPlatform, setAvailableClis, setFeatureFlags } = connectionSlice.actions
 export default connectionSlice.reducer
diff --git a/src/store/crossTabSync.ts b/src/store/crossTabSync.ts
index d07d2476..31a0d2a5 100644
--- a/src/store/crossTabSync.ts
+++ b/src/store/crossTabSync.ts
@@ -159,16 +159,42 @@ function dispatchHydrateBrowserPreferencesFromPersisted(
   }
 }
 
-function handleIncomingRaw(store: StoreLike, key: string, raw: string, previousRaw?: string) {
+function handleIncomingRaw(
+  store: StoreLike,
+  key: string,
+  raw: string,
+  previousRaw?: string,
+  dedupeCheck?: (key: string, raw: string) => boolean,
+) {
   if (key === TABS_STORAGE_KEY) {
     dispatchHydrateTabsFromPersisted(store, raw)
+    // Also hydrate panes from localStorage to keep tabs+panes atomic.
+    // The writing tab's flush() wrote both synchronously, so panes data
+    // is already in localStorage even if the panes event hasn't arrived yet.
+    readAndHydratePairedKey(store, PANES_STORAGE_KEY, dedupeCheck)
   } else if (key === PANES_STORAGE_KEY) {
     dispatchHydratePanesFromPersisted(store, raw)
+    readAndHydratePairedKey(store, TABS_STORAGE_KEY, dedupeCheck)
   } else if (key === BROWSER_PREFERENCES_STORAGE_KEY) {
     dispatchHydrateBrowserPreferencesFromPersisted(store, raw, previousRaw)
   }
 }
 
+function readAndHydratePairedKey(
+  store: StoreLike,
+  key: string,
+  dedupeCheck?: (key: string, raw: string) => boolean,
+) {
+  const raw = localStorage.getItem(key)
+  if (typeof raw !== 'string') return
+  if (dedupeCheck && !dedupeCheck(key, raw)) return
+  if (key === TABS_STORAGE_KEY) {
+    dispatchHydrateTabsFromPersisted(store, raw)
+  } else if (key === PANES_STORAGE_KEY) {
+    dispatchHydratePanesFromPersisted(store, raw)
+  }
+}
+
 export function installCrossTabSync(store: StoreLike): () => void {
   if (typeof window === 'undefined') return () => {}
 
@@ -182,11 +208,20 @@ export function installCrossTabSync(store: StoreLike): () => void {
     }
   }
 
+  // tryDedupeAndMark is passed into handleIncomingRaw so that when a tabs event
+  // triggers a paired panes read from localStorage (or vice versa), the paired
+  // key also goes through dedup. This prevents the later StorageEvent for the
+  // paired key from re-hydrating what we already processed eagerly.
+  const tryDedupeAndMark = (key: string, raw: string): boolean => {
+    if (lastProcessedRawByKey.get(key) === raw) return false
+    lastProcessedRawByKey.set(key, raw)
+    return true
+  }
+
   const handleIncomingRawDeduped = (key: string, raw: string) => {
     const previousRaw = lastProcessedRawByKey.get(key)
-    if (previousRaw === raw) return
-    lastProcessedRawByKey.set(key, raw)
-    handleIncomingRaw(store, key, raw, previousRaw)
+    if (!tryDedupeAndMark(key, raw)) return
+    handleIncomingRaw(store, key, raw, previousRaw, tryDedupeAndMark)
   }
 
   // Keep dedupe state in sync with local writes too. Otherwise, if we process a remote raw,
diff --git a/src/store/panesSlice.ts b/src/store/panesSlice.ts
index 88e97f6a..28c54563 100644
--- a/src/store/panesSlice.ts
+++ b/src/store/panesSlice.ts
@@ -460,6 +460,12 @@ function mergeTerminalState(incoming: PaneNode, local: PaneNode): PaneNode | nul
       }
     }
 
+    // Guard cross-kind overwrites: if local and incoming have different content
+    // kinds, preserve local to prevent pane corruption during cross-tab sync
+    if (incoming.content?.kind !== local.content?.kind) {
+      return local
+    }
+
     return incoming
   }
 
@@ -1154,10 +1160,11 @@ export const panesSlice = createSlice({
         const mergedNode = localNode
           ? mergeTerminalState(incomingNode as PaneNode, localNode)
           : (incomingHasShape ? incomingNode as PaneNode : null)
+        const mergeUsedIncoming = mergedNode !== localNode
         const normalizedNode = mergedNode ? normalizePaneTree(mergedNode, localNode) : null
         if (normalizedNode) {
           mergedLayouts[tabId] = normalizedNode
-          if (incomingHasShape && normalizedNode !== localNode) {
+          if (incomingHasShape && mergeUsedIncoming) {
             incomingLayoutTabIds.add(tabId)
           }
         }
@@ -1263,6 +1270,38 @@ export const panesSlice = createSlice({
         }
       }
     },
+
+    clearDeadTerminals: (state, action: PayloadAction<{ liveTerminalIds: string[] }>) => {
+      const liveSet = new Set(action.payload.liveTerminalIds)
+
+      function clearDeadInNode(node: PaneNode): boolean {
+        if (node.type === 'leaf') {
+          if (
+            node.content?.kind === 'terminal' &&
+            node.content.terminalId &&
+            !liveSet.has(node.content.terminalId)
+          ) {
+            node.content.terminalId = undefined
+            node.content.status = 'creating'
+            node.content.createRequestId = nanoid()
+            return true
+          }
+          return false
+        }
+        if (node.type === 'split' && Array.isArray(node.children)) {
+          let changed = false
+          for (const child of node.children) {
+            if (clearDeadInNode(child)) changed = true
+          }
+          return changed
+        }
+        return false
+      }
+
+      for (const layout of Object.values(state.layouts)) {
+        clearDeadInNode(layout)
+      }
+    },
   },
 })
 
@@ -1292,6 +1331,7 @@ export const {
   requestPaneRename,
   clearPaneRenameRequest,
   toggleZoom,
+  clearDeadTerminals,
 } = panesSlice.actions
 
 export default panesSlice.reducer
diff --git a/src/store/selectors/sidebarSelectors.ts b/src/store/selectors/sidebarSelectors.ts
index cc92dd5d..612b356c 100644
--- a/src/store/selectors/sidebarSelectors.ts
+++ b/src/store/selectors/sidebarSelectors.ts
@@ -6,6 +6,7 @@ import { collectSessionRefsFromNode, collectSessionRefsFromTabs } from '@/lib/se
 import { getAgentChatProviderConfig } from '@/lib/agent-chat-utils'
 import { getSessionMetadata } from '@/lib/session-metadata'
 import type { SessionListMetadata } from '../types'
+import { getLeafDirectoryName, matchTitleTierMetadata } from '../../../shared/session-title-search.js'
 
 export interface SidebarSessionItem {
   id: string
@@ -28,6 +29,7 @@ export interface SidebarSessionItem {
   isNonInteractive?: boolean
   firstUserMessage?: string
   hasTitle: boolean
+  isFallback?: true
 }
 
 const EMPTY_ACTIVITY: Record<string, number> = {}
@@ -48,12 +50,13 @@ const selectShowNoninteractiveSessions = (state: RootState) => state.settings.se
 const selectHideEmptySessions = (state: RootState) => state.settings.settings.sidebar?.hideEmptySessions ?? true
 const selectExcludeFirstChatSubstrings = (state: RootState) => state.settings.settings.sidebar?.excludeFirstChatSubstrings ?? EMPTY_STRINGS
 const selectExcludeFirstChatMustStart = (state: RootState) => state.settings.settings.sidebar?.excludeFirstChatMustStart ?? false
+const selectAppliedQuery = (state: RootState) => state.sessions.windows?.sidebar?.appliedQuery ?? ''
+const selectAppliedSearchTier = (state: RootState) => state.sessions.windows?.sidebar?.appliedSearchTier
 const selectTerminals = (_state: RootState, terminals: BackgroundTerminal[]) => terminals
 const selectFilter = (_state: RootState, _terminals: BackgroundTerminal[], filter: string) => filter
 
 function getProjectName(projectPath: string): string {
-  const parts = projectPath.replace(/\\/g, '/').split('/')
-  return parts[parts.length - 1] || projectPath
+  return getLeafDirectoryName(projectPath) ?? projectPath
 }
 
 export function buildSessionItems(
@@ -164,6 +167,7 @@ export function buildSessionItems(
       isSubagent: input.metadata?.isSubagent,
       isNonInteractive: input.metadata?.isNonInteractive,
       firstUserMessage: input.metadata?.firstUserMessage,
+      isFallback: true,
     })
   }
 
@@ -252,6 +256,29 @@ function filterSessionItems(items: SidebarSessionItem[], filter: string): Sideba
   )
 }
 
+function filterSessionItemsForAppliedSearch(
+  items: SidebarSessionItem[],
+  appliedQuery: string,
+  appliedSearchTier?: 'title' | 'userMessages' | 'fullText',
+): SidebarSessionItem[] {
+  const query = appliedQuery.trim()
+  if (!query) return items
+
+  const tier = appliedSearchTier ?? 'title'
+  if (tier !== 'title') {
+    return items.filter((item) => !item.isFallback)
+  }
+
+  return items.filter((item) => (
+    !item.isFallback || matchTitleTierMetadata({
+      title: item.title,
+      projectPath: item.projectPath,
+      cwd: item.cwd,
+      firstUserMessage: item.firstUserMessage,
+    }, query) !== null
+  ))
+}
+
 export interface VisibilitySettings {
   showSubagents: boolean
   ignoreCodexSubagents: boolean
@@ -297,31 +324,52 @@ export function filterSessionItemsByVisibility(
   })
 }
 
-export function sortSessionItems(items: SidebarSessionItem[], sortMode: string): SidebarSessionItem[] {
+export function sortSessionItems(
+  items: SidebarSessionItem[],
+  sortMode: string,
+  options?: { disableTabPinning?: boolean },
+): SidebarSessionItem[] {
   const sorted = [...items]
 
   const active = sorted.filter((i) => !i.archived)
   const archived = sorted.filter((i) => i.archived)
 
+  const compareByRecency = (a: SidebarSessionItem, b: SidebarSessionItem) => b.timestamp - a.timestamp
+  const compareByActivity = (a: SidebarSessionItem, b: SidebarSessionItem) => {
+    const aHasRatcheted = typeof a.ratchetedActivity === 'number'
+    const bHasRatcheted = typeof b.ratchetedActivity === 'number'
+    if (aHasRatcheted !== bHasRatcheted) return aHasRatcheted ? -1 : 1
+    const aTime = a.ratchetedActivity ?? a.timestamp
+    const bTime = b.ratchetedActivity ?? b.timestamp
+    return bTime - aTime
+  }
+
   const sortByMode = (list: SidebarSessionItem[]) => {
     const copy = [...list]
 
     if (sortMode === 'recency') {
-      return copy.sort((a, b) => b.timestamp - a.timestamp)
+      return copy.sort(compareByRecency)
     }
 
     if (sortMode === 'recency-pinned') {
+      if (options?.disableTabPinning) {
+        return copy.sort(compareByRecency)
+      }
+
       const withTabs = copy.filter((i) => i.hasTab)
       const withoutTabs = copy.filter((i) => !i.hasTab)
 
-      // Sort both groups by recency (timestamp)
-      withTabs.sort((a, b) => b.timestamp - a.timestamp)
-      withoutTabs.sort((a, b) => b.timestamp - a.timestamp)
+      withTabs.sort(compareByRecency)
+      withoutTabs.sort(compareByRecency)
 
       return [...withTabs, ...withoutTabs]
     }
 
     if (sortMode === 'activity') {
+      if (options?.disableTabPinning) {
+        return copy.sort(compareByActivity)
+      }
+
       const withTabs = copy.filter((i) => i.hasTab)
       const withoutTabs = copy.filter((i) => !i.hasTab)
 
@@ -372,6 +420,8 @@ export const makeSelectSortedSessionItems = () =>
       selectHideEmptySessions,
       selectExcludeFirstChatSubstrings,
       selectExcludeFirstChatMustStart,
+      selectAppliedQuery,
+      selectAppliedSearchTier,
       selectTerminals,
       selectFilter,
     ],
@@ -387,6 +437,8 @@ export const makeSelectSortedSessionItems = () =>
       hideEmptySessions,
       excludeFirstChatSubstrings,
       excludeFirstChatMustStart,
+      appliedQuery,
+      appliedSearchTier,
       terminals,
       filter
     ) => {
@@ -399,8 +451,11 @@ export const makeSelectSortedSessionItems = () =>
         excludeFirstChatSubstrings,
         excludeFirstChatMustStart,
       })
-      const filtered = filterSessionItems(visible, filter)
-      return sortSessionItems(filtered, sortMode)
+      const searchAware = filterSessionItemsForAppliedSearch(visible, appliedQuery, appliedSearchTier)
+      const filtered = filterSessionItems(searchAware, filter)
+      return sortSessionItems(filtered, sortMode, {
+        disableTabPinning: appliedQuery.trim().length > 0,
+      })
     }
   )
 
diff --git a/src/store/sessionsSlice.ts b/src/store/sessionsSlice.ts
index e1117206..8006f225 100644
--- a/src/store/sessionsSlice.ts
+++ b/src/store/sessionsSlice.ts
@@ -6,6 +6,7 @@ export type SessionWindowLoadingKind = 'initial' | 'search' | 'background' | 'pa
 export interface SessionWindowState {
   projects: ProjectGroup[]
   lastLoadedAt?: number
+  resultVersion?: number
   totalSessions?: number
   oldestLoadedTimestamp?: number
   oldestLoadedSessionId?: string
@@ -15,6 +16,8 @@ export interface SessionWindowState {
   error?: string
   query?: string
   searchTier?: 'title' | 'userMessages' | 'fullText'
+  appliedQuery?: string
+  appliedSearchTier?: 'title' | 'userMessages' | 'fullText'
   deepSearchPending?: boolean
   partial?: boolean
   partialReason?: 'budget' | 'io_error'
@@ -115,6 +118,37 @@ function syncTopLevelFromWindow(state: SessionsState, surface: string) {
   state.loadingKind = window.loadingKind
 }
 
+type SessionWindowCommitPayload = {
+  surface: string
+  projects: ProjectGroup[]
+  totalSessions?: number
+  oldestLoadedTimestamp?: number
+  oldestLoadedSessionId?: string
+  hasMore?: boolean
+  query?: string
+  searchTier?: 'title' | 'userMessages' | 'fullText'
+  deepSearchPending?: boolean
+  partial?: boolean
+  partialReason?: 'budget' | 'io_error'
+}
+
+function commitWindowPayload(
+  window: SessionWindowState,
+  payload: SessionWindowCommitPayload,
+) {
+  window.projects = normalizeProjects(payload.projects)
+  window.lastLoadedAt = Date.now()
+  window.resultVersion = (window.resultVersion ?? 0) + 1
+  window.totalSessions = payload.totalSessions
+  window.oldestLoadedTimestamp = payload.oldestLoadedTimestamp
+  window.oldestLoadedSessionId = payload.oldestLoadedSessionId
+  window.hasMore = payload.hasMore
+  window.error = undefined
+  window.deepSearchPending = payload.deepSearchPending ?? false
+  window.partial = payload.partial
+  window.partialReason = payload.partialReason
+}
+
 function syncActiveWindowFromTopLevel(state: SessionsState) {
   if (!state.activeSurface) return
   const window = ensureWindow(state, state.activeSurface)
@@ -190,37 +224,42 @@ export const sessionsSlice = createSlice({
         }
       }
     },
-    setSessionWindowData: (
+    commitSessionWindowReplacement: (
       state,
-      action: PayloadAction<{
-        surface: string
-        projects: ProjectGroup[]
-        totalSessions?: number
-        oldestLoadedTimestamp?: number
-        oldestLoadedSessionId?: string
-        hasMore?: boolean
-        query?: string
-        searchTier?: 'title' | 'userMessages' | 'fullText'
-        deepSearchPending?: boolean
-        partial?: boolean
-        partialReason?: 'budget' | 'io_error'
-      }>,
+      action: PayloadAction<SessionWindowCommitPayload>,
     ) => {
       const window = ensureWindow(state, action.payload.surface)
-      window.projects = normalizeProjects(action.payload.projects)
-      window.lastLoadedAt = Date.now()
-      window.totalSessions = action.payload.totalSessions
-      window.oldestLoadedTimestamp = action.payload.oldestLoadedTimestamp
-      window.oldestLoadedSessionId = action.payload.oldestLoadedSessionId
-      window.hasMore = action.payload.hasMore
+      commitWindowPayload(window, action.payload)
       window.loading = false
       window.loadingKind = undefined
-      window.error = undefined
-      window.deepSearchPending = action.payload.deepSearchPending ?? false
-      window.partial = action.payload.partial
-      window.partialReason = action.payload.partialReason
-      if (action.payload.query !== undefined) window.query = action.payload.query
-      if (action.payload.searchTier !== undefined) window.searchTier = action.payload.searchTier
+      if (action.payload.query !== undefined) {
+        window.query = action.payload.query
+        window.appliedQuery = action.payload.query
+      }
+      if (action.payload.searchTier !== undefined) {
+        window.searchTier = action.payload.searchTier
+        window.appliedSearchTier = action.payload.searchTier
+      }
+      if (!state.activeSurface || state.activeSurface === action.payload.surface) {
+        syncTopLevelFromWindow(state, action.payload.surface)
+      }
+    },
+    commitSessionWindowVisibleRefresh: (
+      state,
+      action: PayloadAction<SessionWindowCommitPayload & { preserveLoading?: boolean }>,
+    ) => {
+      const window = ensureWindow(state, action.payload.surface)
+      commitWindowPayload(window, action.payload)
+      if (!action.payload.preserveLoading) {
+        window.loading = false
+        window.loadingKind = undefined
+      }
+      if (action.payload.query !== undefined) {
+        window.appliedQuery = action.payload.query
+      }
+      if (action.payload.searchTier !== undefined) {
+        window.appliedSearchTier = action.payload.searchTier
+      }
       if (!state.activeSurface || state.activeSurface === action.payload.surface) {
         syncTopLevelFromWindow(state, action.payload.surface)
       }
@@ -385,7 +424,8 @@ export const {
   setActiveSessionSurface,
   setSessionWindowLoading,
   setSessionWindowError,
-  setSessionWindowData,
+  commitSessionWindowReplacement,
+  commitSessionWindowVisibleRefresh,
   markWsSnapshotReceived,
   resetWsSnapshotReceived,
   setProjects,
diff --git a/src/store/sessionsThunks.ts b/src/store/sessionsThunks.ts
index f73c387b..101be949 100644
--- a/src/store/sessionsThunks.ts
+++ b/src/store/sessionsThunks.ts
@@ -7,8 +7,9 @@ import {
 import type { AppDispatch, RootState } from './store'
 import type { ProjectGroup } from './types'
 import {
+  commitSessionWindowReplacement,
+  commitSessionWindowVisibleRefresh,
   setActiveSessionSurface,
-  setSessionWindowData,
   setSessionWindowError,
   setSessionWindowLoading,
   type SessionWindowLoadingKind,
@@ -110,6 +111,15 @@ export function mergeSearchResults(titleResults: SearchResult[], deepResults: Se
   return Array.from(merged.values())
 }
 
+type SessionWindowSearchContext = {
+  query: string
+  searchTier: SearchOptions['tier']
+}
+
+type VisibleResultIdentity = SessionWindowSearchContext & {
+  resultVersion: number
+}
+
 function mergeProjects(existing: ProjectGroup[], incoming: ProjectGroup[]): ProjectGroup[] {
   const projectMap = new Map<string, ProjectGroup>()
   const seenKeys = new Map<string, Set<string>>()
@@ -172,6 +182,79 @@ function getLoadingKind(args: {
   return 'background'
 }
 
+function normalizeWindowSearchContext(context?: {
+  query?: string
+  searchTier?: SearchOptions['tier']
+}): SessionWindowSearchContext {
+  return {
+    query: context?.query?.trim() ?? '',
+    searchTier: context?.searchTier ?? 'title',
+  }
+}
+
+function getRequestedWindowSearchContext(windowState?: {
+  query?: string
+  searchTier?: SearchOptions['tier']
+}) {
+  return normalizeWindowSearchContext({
+    query: windowState?.query,
+    searchTier: windowState?.searchTier,
+  })
+}
+
+function getVisibleWindowSearchContext(windowState?: {
+  query?: string
+  searchTier?: SearchOptions['tier']
+  appliedQuery?: string
+  appliedSearchTier?: SearchOptions['tier']
+}) {
+  const hasAppliedContext = windowState?.appliedQuery !== undefined
+    || windowState?.appliedSearchTier !== undefined
+
+  if (hasAppliedContext) {
+    return normalizeWindowSearchContext({
+      query: windowState?.appliedQuery ?? '',
+      searchTier: windowState?.appliedSearchTier ?? windowState?.searchTier ?? 'title',
+    })
+  }
+
+  return getRequestedWindowSearchContext(windowState)
+}
+
+function getVisibleResultIdentity(windowState?: {
+  query?: string
+  searchTier?: SearchOptions['tier']
+  appliedQuery?: string
+  appliedSearchTier?: SearchOptions['tier']
+  resultVersion?: number
+}): VisibleResultIdentity {
+  const visibleContext = getVisibleWindowSearchContext(windowState)
+  return {
+    ...visibleContext,
+    resultVersion: windowState?.resultVersion ?? 0,
+  }
+}
+
+function searchContextsEqual(
+  left: SessionWindowSearchContext,
+  right: SessionWindowSearchContext,
+) {
+  return left.query === right.query && left.searchTier === right.searchTier
+}
+
+function visibleResultIdentitiesEqual(
+  left: VisibleResultIdentity,
+  right: VisibleResultIdentity,
+) {
+  return searchContextsEqual(left, right) && left.resultVersion === right.resultVersion
+}
+
+function hasCommittedWindowData(windowState?: {
+  lastLoadedAt?: number
+}) {
+  return typeof windowState?.lastLoadedAt === 'number'
+}
+
 export function activateSessionSurface(surface: SessionSurface) {
   return (dispatch: AppDispatch) => {
     dispatch(setActiveSessionSurface(surface))
@@ -202,28 +285,168 @@ function buildSearchPayload(
   }
 }
 
+function getSidebarVisibilityOptions(state: RootState) {
+  const sidebarSettings = state.settings?.settings?.sidebar
+  return {
+    includeSubagents: sidebarSettings?.showSubagents || undefined,
+    includeNonInteractive: sidebarSettings?.showNoninteractiveSessions || undefined,
+    includeEmpty: sidebarSettings?.hideEmptySessions === false || undefined,
+  }
+}
+
+function canCommitVisibleRefresh(args: {
+  generation: number
+  getState: () => RootState
+  surface: SessionSurface
+  identity: VisibleResultIdentity
+}) {
+  if (args.generation !== sessionWindowThunkGeneration) return false
+  const windowState = args.getState().sessions.windows?.[args.surface]
+  return visibleResultIdentitiesEqual(getVisibleResultIdentity(windowState), args.identity)
+}
+
+async function refreshVisibleSessionWindowSilently(args: {
+  dispatch: AppDispatch
+  getState: () => RootState
+  surface: SessionSurface
+  generation: number
+  identity: VisibleResultIdentity
+  preserveLoadingState: boolean
+}) {
+  const {
+    dispatch,
+    getState,
+    surface,
+    generation,
+    preserveLoadingState,
+  } = args
+  let identity = args.identity
+  const visibilityOpts = getSidebarVisibilityOptions(getState())
+  const controller = new AbortController()
+  const canCommit = () => canCommitVisibleRefresh({
+    generation,
+    getState,
+    surface,
+    identity,
+  })
+  const commitData = (payload: ReturnType<typeof buildSearchPayload> | {
+    surface: SessionSurface
+    projects: ProjectGroup[]
+    totalSessions?: number
+    oldestLoadedTimestamp?: number
+    oldestLoadedSessionId?: string
+    hasMore?: boolean
+    query?: string
+    searchTier?: SearchOptions['tier']
+  }) => {
+    if (!canCommit()) return false
+    dispatch(commitSessionWindowVisibleRefresh({
+      ...payload,
+      preserveLoading: preserveLoadingState,
+    }))
+    identity = getVisibleResultIdentity(getState().sessions.windows?.[surface])
+    return true
+  }
+
+  if (!preserveLoadingState) {
+    dispatch(setSessionWindowLoading({
+      surface,
+      loading: true,
+      loadingKind: 'background',
+    }))
+  }
+
+  try {
+    if (identity.query) {
+      if (identity.searchTier !== 'title') {
+        const titleResponse = await searchSessions({
+          query: identity.query,
+          tier: 'title',
+          signal: controller.signal,
+          ...visibilityOpts,
+        })
+        if (!commitData(buildSearchPayload(surface, titleResponse.results, identity.query, identity.searchTier, true))) {
+          return
+        }
+
+        try {
+          const deepResponse = await searchSessions({
+            query: identity.query,
+            tier: identity.searchTier,
+            signal: controller.signal,
+            ...visibilityOpts,
+          })
+          const merged = mergeSearchResults(titleResponse.results, deepResponse.results)
+          commitData(buildSearchPayload(surface, merged, identity.query, identity.searchTier, false, {
+            partial: deepResponse.partial,
+            partialReason: deepResponse.partialReason,
+          }))
+        } catch {
+          commitData(buildSearchPayload(surface, titleResponse.results, identity.query, identity.searchTier, false))
+        }
+        return
+      }
+
+      const response = await searchSessions({
+        query: identity.query,
+        tier: identity.searchTier,
+        signal: controller.signal,
+        ...visibilityOpts,
+      })
+      commitData(buildSearchPayload(surface, response.results, identity.query, identity.searchTier, false, {
+        partial: response.partial,
+        partialReason: response.partialReason,
+      }))
+      return
+    }
+
+    const response = await fetchSidebarSessionsSnapshot({
+      limit: 50,
+      signal: controller.signal,
+      ...visibilityOpts,
+    })
+    const nextProjects = Array.isArray(response) ? response : (response?.projects ?? [])
+    commitData({
+      surface,
+      projects: nextProjects,
+      totalSessions: response?.totalSessions,
+      oldestLoadedTimestamp: response?.oldestIncludedTimestamp,
+      oldestLoadedSessionId: response?.oldestIncludedSessionId,
+      hasMore: response?.hasMore,
+      query: identity.query,
+      searchTier: identity.searchTier,
+    })
+  } catch {
+    if (!preserveLoadingState && canCommit()) {
+      dispatch(setSessionWindowLoading({
+        surface,
+        loading: false,
+      }))
+    }
+  }
+}
+
 export function fetchSessionWindow(args: FetchSessionWindowArgs) {
   return async (dispatch: AppDispatch, getState: () => RootState) => {
     const { surface, query = '', searchTier = 'title', append = false } = args
     const trimmedQuery = query.trim()
     const state = getState()
     const windowState = state.sessions.windows?.[surface]
-    const sidebarSettings = state.settings?.settings?.sidebar
-    const visibilityOpts = {
-      includeSubagents: sidebarSettings?.showSubagents || undefined,
-      includeNonInteractive: sidebarSettings?.showNoninteractiveSessions || undefined,
-      includeEmpty: sidebarSettings?.hideEmptySessions === false || undefined,
-    }
+    const visibilityOpts = getSidebarVisibilityOptions(state)
     const previousQuery = (windowState?.query ?? '').trim()
     const previousTier = windowState?.searchTier ?? 'title'
-    const hasCommittedWindow = typeof windowState?.lastLoadedAt === 'number'
+    const hasCommittedWindow = hasCommittedWindowData(windowState)
     const hasCommittedItems = (windowState?.projects ?? []).some((project) => (project.sessions?.length ?? 0) > 0)
+    const previousVisibleQuery = windowState?.appliedQuery?.trim()
+      ?? (hasCommittedWindow ? previousQuery : '')
+    const previousVisibleTier = windowState?.appliedSearchTier
+      ?? (hasCommittedWindow ? previousTier : 'title')
     const loadingKind = getLoadingKind({
       priority: args.priority,
       append,
       trimmedQuery,
-      previousQuery,
-      previousTier,
+      previousQuery: previousVisibleQuery,
+      previousTier: previousVisibleTier,
       nextTier: searchTier,
       hasCommittedWindow,
       hasCommittedItems,
@@ -256,7 +479,7 @@ export function fetchSessionWindow(args: FetchSessionWindowArgs) {
             })
             if (controller.signal.aborted) return
 
-            dispatch(setSessionWindowData(buildSearchPayload(surface, titleResponse.results, trimmedQuery, searchTier, true)))
+            dispatch(commitSessionWindowReplacement(buildSearchPayload(surface, titleResponse.results, trimmedQuery, searchTier, true)))
 
             // Phase 2: file-based search
             try {
@@ -269,7 +492,7 @@ export function fetchSessionWindow(args: FetchSessionWindowArgs) {
               if (controller.signal.aborted) return
 
               const merged = mergeSearchResults(titleResponse.results, deepResponse.results)
-              dispatch(setSessionWindowData(buildSearchPayload(surface, merged, trimmedQuery, searchTier, false, {
+              dispatch(commitSessionWindowReplacement(buildSearchPayload(surface, merged, trimmedQuery, searchTier, false, {
                 partial: deepResponse.partial,
                 partialReason: deepResponse.partialReason,
               })))
@@ -277,7 +500,7 @@ export function fetchSessionWindow(args: FetchSessionWindowArgs) {
               if (controller.signal.aborted) return
               // Phase 2 failed but Phase 1 data is already displayed.
               // Clear the pending indicator and report the error.
-              dispatch(setSessionWindowData(buildSearchPayload(surface, titleResponse.results, trimmedQuery, searchTier, false)))
+              dispatch(commitSessionWindowReplacement(buildSearchPayload(surface, titleResponse.results, trimmedQuery, searchTier, false)))
               dispatch(setSessionWindowError({
                 surface,
                 error: phase2Error instanceof Error ? phase2Error.message : 'Deep search failed',
@@ -293,7 +516,7 @@ export function fetchSessionWindow(args: FetchSessionWindowArgs) {
             })
             if (controller.signal.aborted) return
 
-            dispatch(setSessionWindowData(buildSearchPayload(surface, response.results, trimmedQuery, searchTier, false, {
+            dispatch(commitSessionWindowReplacement(buildSearchPayload(surface, response.results, trimmedQuery, searchTier, false, {
               partial: response.partial,
               partialReason: response.partialReason,
             })))
@@ -317,7 +540,7 @@ export function fetchSessionWindow(args: FetchSessionWindowArgs) {
           ? mergeProjects(windowState?.projects ?? [], nextProjects)
           : nextProjects
 
-        dispatch(setSessionWindowData({
+        dispatch(commitSessionWindowReplacement({
           surface,
           projects,
           totalSessions: response?.totalSessions,
@@ -360,12 +583,25 @@ export function refreshActiveSessionWindow() {
     const surface = getState().sessions.activeSurface as SessionSurface | undefined
     if (!surface) return
     const windowState = getState().sessions.windows[surface]
-    await dispatch(fetchSessionWindow({
+    if (!hasCommittedWindowData(windowState)) {
+      const requestedSearchContext = getRequestedWindowSearchContext(windowState)
+      await dispatch(fetchSessionWindow({
+        surface,
+        priority: 'background',
+        query: requestedSearchContext.query,
+        searchTier: requestedSearchContext.searchTier,
+      }) as any)
+      return
+    }
+
+    await refreshVisibleSessionWindowSilently({
+      dispatch,
+      getState,
       surface,
-      priority: 'visible',
-      query: windowState?.query,
-      searchTier: windowState?.searchTier,
-    }) as any)
+      generation: sessionWindowThunkGeneration,
+      identity: getVisibleResultIdentity(windowState),
+      preserveLoadingState: inFlightRequests.get(surface) !== null && inFlightRequests.get(surface) !== undefined,
+    })
   }
 }
 
@@ -391,6 +627,49 @@ export function queueActiveSessionWindowRefresh() {
       try {
         while (generation === sessionWindowThunkGeneration) {
           const activeRequest = inFlightRequests.get(activeSurface) ?? null
+          const windowState = getState().sessions.windows[activeSurface]
+          const hasCommittedWindow = hasCommittedWindowData(windowState)
+
+          if (!hasCommittedWindow) {
+            if (activeRequest) {
+              try {
+                await activeRequest
+              } catch {
+                // A queued invalidation should still retry after an aborted/failed direct fetch.
+              }
+              continue
+            }
+            if (!state.queued) break
+            state.queued = false
+            const requestedSearchContext = getRequestedWindowSearchContext(windowState)
+            await dispatch(fetchSessionWindow({
+              surface: activeSurface,
+              priority: 'background',
+              query: requestedSearchContext.query,
+              searchTier: requestedSearchContext.searchTier,
+            }) as any)
+            continue
+          }
+
+          const requestedSearchContext = getRequestedWindowSearchContext(windowState)
+          const visibleSearchContext = getVisibleWindowSearchContext(windowState)
+          const hasRequestedAppliedDrift = !searchContextsEqual(
+            requestedSearchContext,
+            visibleSearchContext,
+          )
+          if (hasRequestedAppliedDrift) {
+            if (!state.queued) break
+            state.queued = false
+            await refreshVisibleSessionWindowSilently({
+              dispatch,
+              getState,
+              surface: activeSurface,
+              generation,
+              identity: getVisibleResultIdentity(windowState),
+              preserveLoadingState: activeRequest !== null,
+            })
+            continue
+          }
           if (activeRequest) {
             try {
               await activeRequest
@@ -401,13 +680,14 @@ export function queueActiveSessionWindowRefresh() {
           }
           if (!state.queued) break
           state.queued = false
-          const windowState = getState().sessions.windows[activeSurface]
-          await dispatch(fetchSessionWindow({
+          await refreshVisibleSessionWindowSilently({
+            dispatch,
+            getState,
             surface: activeSurface,
-            priority: 'background',
-            query: windowState?.query,
-            searchTier: windowState?.searchTier,
-          }) as any)
+            generation,
+            identity: getVisibleResultIdentity(windowState),
+            preserveLoadingState: false,
+          })
         }
       } finally {
         if (invalidationRefreshState.get(activeSurface) === state) {
diff --git a/test/e2e-browser/specs/tab-management.spec.ts b/test/e2e-browser/specs/tab-management.spec.ts
index 27e114d0..9277f742 100644
--- a/test/e2e-browser/specs/tab-management.spec.ts
+++ b/test/e2e-browser/specs/tab-management.spec.ts
@@ -164,10 +164,8 @@ test.describe('Tab Management', () => {
     expect(sent.filter((msg: any) => msg?.type === 'terminal.resize')).toHaveLength(0)
   })
 
-  test.skip('keyboard shortcut creates new tab', async ({ freshellPage, page, harness }) => {
-    // Ctrl+T is intercepted by Chromium in headed mode and cannot be tested.
-    // The app's keyboard shortcut handling is covered by unit tests.
-    await page.keyboard.press('Control+t')
+  test('keyboard shortcut creates new tab', async ({ freshellPage, page, harness }) => {
+    await page.keyboard.press('Alt+T')
     await harness.waitForTabCount(2)
   })
 
diff --git a/test/e2e/network-setup.test.tsx b/test/e2e/network-setup.test.tsx
index 5508d456..515c2312 100644
--- a/test/e2e/network-setup.test.tsx
+++ b/test/e2e/network-setup.test.tsx
@@ -47,6 +47,15 @@ const configuredRemoteStatus: NetworkStatusResponse = {
   firewall: { platform: 'linux-none', active: false, portOpen: true, commands: [], configuring: false },
 }
 
+function resetNetworkMocks(defaultPostResult: unknown = configuredRemoteStatus) {
+  mockPost.mockReset()
+  mockGet.mockReset()
+  mockFetchFirewallConfig.mockReset()
+  mockCancelFirewallConfirmation.mockReset()
+  mockCancelFirewallConfirmation.mockResolvedValue(undefined)
+  mockPost.mockResolvedValue(defaultPostResult)
+}
+
 function createStore(networkStatus: NetworkStatusResponse | null = unconfiguredStatus) {
   return configureStore({
     reducer: {
@@ -73,22 +82,14 @@ function createStore(networkStatus: NetworkStatusResponse | null = unconfiguredS
   })
 }
 
-function resetNetworkMocks() {
-  mockPost.mockReset()
-  mockGet.mockReset()
-  mockFetchFirewallConfig.mockReset()
-  mockCancelFirewallConfirmation.mockReset()
-  mockCancelFirewallConfirmation.mockResolvedValue(undefined)
-}
-
-function openSafetyTab() {
-  fireEvent.click(screen.getByRole('tab', { name: /safety/i }))
+async function openSafetySettings() {
+  fireEvent.click(screen.getByRole('tab', { name: /^safety$/i }))
+  return screen.findByRole('switch', { name: /remote access/i })
 }
 
 describe('Network Setup Wizard (e2e)', () => {
   beforeEach(() => {
     resetNetworkMocks()
-    mockPost.mockResolvedValue(configuredRemoteStatus)
   })
 
   afterEach(() => {
@@ -297,7 +298,7 @@ describe('Settings network section (e2e)', () => {
     cleanup()
   })
 
-  it('renders remote access toggle in settings', () => {
+  it('renders remote access toggle in settings', async () => {
     const store = createStore(unconfiguredStatus)
     render(
       <Provider store={store}>
@@ -305,8 +306,7 @@ describe('Settings network section (e2e)', () => {
       </Provider>,
     )
 
-    openSafetyTab()
-    expect(screen.getByRole('switch', { name: /remote access/i })).toBeInTheDocument()
+    expect(await openSafetySettings()).toBeInTheDocument()
   })
 
   it('toggles remote access on and dispatches configure', async () => {
@@ -319,8 +319,7 @@ describe('Settings network section (e2e)', () => {
       </Provider>,
     )
 
-    openSafetyTab()
-    const toggle = screen.getByRole('switch', { name: /remote access/i })
+    const toggle = await openSafetySettings()
     fireEvent.click(toggle)
 
     await waitFor(() => {
@@ -359,8 +358,8 @@ describe('Settings network section (e2e)', () => {
       </Provider>,
     )
 
-    openSafetyTab()
-    fireEvent.click(screen.getByRole('button', { name: /fix firewall/i }))
+    await openSafetySettings()
+    fireEvent.click(screen.getByRole('button', { name: /fix firewall configuration/i }))
 
     const confirmationDialog = await screen.findByRole('dialog', { name: /administrator approval required/i })
     expect(confirmationDialog).toBeInTheDocument()
diff --git a/test/e2e/open-tab-session-sidebar-visibility.test.tsx b/test/e2e/open-tab-session-sidebar-visibility.test.tsx
index dd41b9d3..d6fa401f 100644
--- a/test/e2e/open-tab-session-sidebar-visibility.test.tsx
+++ b/test/e2e/open-tab-session-sidebar-visibility.test.tsx
@@ -796,7 +796,7 @@ describe('open tab session sidebar visibility (e2e)', () => {
     expect(fetchSidebarSessionsSnapshot.mock.calls.length).toBeLessThanOrEqual(2)
   })
 
-  it('keeps loaded search results visible and shows no search chrome during websocket revalidation', async () => {
+  it('keeps stale applied search results visible and revalidates them silently during websocket refresh after clearing search', async () => {
     const searchProjects = [{
       projectPath: '/search',
       sessions: [{
@@ -807,7 +807,9 @@ describe('open tab session sidebar visibility (e2e)', () => {
         title: 'Search Result',
       }],
     }]
+    const browseDeferred = createDeferred<any>()
     const deferred = createDeferred<any>()
+    fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseDeferred.promise)
     searchSessions.mockReturnValueOnce(deferred.promise)
 
     const store = createStore({
@@ -822,6 +824,8 @@ describe('open tab session sidebar visibility (e2e)', () => {
             loading: false,
             query: 'search',
             searchTier: 'title',
+            appliedQuery: 'search',
+            appliedSearchTier: 'title',
           },
         },
       },
@@ -837,6 +841,15 @@ describe('open tab session sidebar visibility (e2e)', () => {
       expect(screen.getAllByText('Search Result').length).toBeGreaterThan(0)
     })
 
+    fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: '' } })
+
+    await waitFor(() => {
+      expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    })
+
+    expect(screen.getAllByText('Search Result').length).toBeGreaterThan(0)
+    expect(screen.queryByTestId('search-loading')).not.toBeInTheDocument()
+
     act(() => {
       broadcastWs({
         type: 'sessions.changed',
@@ -872,6 +885,17 @@ describe('open tab session sidebar visibility (e2e)', () => {
       })
       await Promise.resolve()
     })
+
+    await act(async () => {
+      browseDeferred.resolve({
+        projects: [],
+        totalSessions: 0,
+        oldestIncludedTimestamp: 0,
+        oldestIncludedSessionId: '',
+        hasMore: false,
+      })
+      await Promise.resolve()
+    })
   })
 
   it('blocks with loading UI when websocket recovery starts from an empty, uncommitted sidebar window', async () => {
@@ -936,7 +960,7 @@ describe('open tab session sidebar visibility (e2e)', () => {
     })
   })
 
-  it('keeps direct active-query refreshes silent and only shows searching for actual query changes', async () => {
+  it('keeps direct refreshes on the visible applied search silent and only shows searching for actual query changes', async () => {
     const searchProjects = [{
       projectPath: '/search',
       sessions: [{
@@ -947,8 +971,10 @@ describe('open tab session sidebar visibility (e2e)', () => {
         title: 'Search Result',
       }],
     }]
+    const browseDeferred = createDeferred<any>()
     const refreshDeferred = createDeferred<any>()
     const queryChangeDeferred = createDeferred<any>()
+    fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseDeferred.promise)
     searchSessions
       .mockReturnValueOnce(refreshDeferred.promise)
       .mockReturnValueOnce(queryChangeDeferred.promise)
@@ -965,6 +991,8 @@ describe('open tab session sidebar visibility (e2e)', () => {
             loading: false,
             query: 'search',
             searchTier: 'title',
+            appliedQuery: 'search',
+            appliedSearchTier: 'title',
           },
         },
       },
@@ -980,6 +1008,15 @@ describe('open tab session sidebar visibility (e2e)', () => {
       expect(screen.getAllByText('Search Result').length).toBeGreaterThan(0)
     })
 
+    fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: '' } })
+
+    await waitFor(() => {
+      expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    })
+
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('search')
+
     const refreshRequest = store.dispatch((sessionsThunks as any).refreshActiveSessionWindow())
 
     await waitFor(() => {
@@ -993,6 +1030,7 @@ describe('open tab session sidebar visibility (e2e)', () => {
 
     expect(screen.getAllByText('Search Result').length).toBeGreaterThan(0)
     expect(screen.queryByTestId('search-loading')).not.toBeInTheDocument()
+    expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
 
     await act(async () => {
       refreshDeferred.resolve({
@@ -1011,6 +1049,23 @@ describe('open tab session sidebar visibility (e2e)', () => {
       await refreshRequest
     })
 
+    await act(async () => {
+      browseDeferred.resolve({
+        projects: [],
+        totalSessions: 0,
+        oldestIncludedTimestamp: 0,
+        oldestIncludedSessionId: '',
+        hasMore: false,
+      })
+      await Promise.resolve()
+    })
+
+    await waitFor(() => {
+      expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('')
+      expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('title')
+      expect(screen.queryByText('Search Result')).not.toBeInTheDocument()
+    })
+
     fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'search plus' } })
 
     await waitFor(() => {
diff --git a/test/e2e/settings-devices-flow.test.tsx b/test/e2e/settings-devices-flow.test.tsx
index 588af9cb..c6cfca53 100644
--- a/test/e2e/settings-devices-flow.test.tsx
+++ b/test/e2e/settings-devices-flow.test.tsx
@@ -130,7 +130,7 @@ describe('settings devices management flow (e2e)', () => {
       </Provider>,
     )
 
-    fireEvent.click(screen.getByRole('tab', { name: /safety/i }))
+    fireEvent.click(screen.getByRole('tab', { name: /^safety$/i }))
     expect(screen.getAllByLabelText('Device name for studio-mac')).toHaveLength(1)
 
     const devicesHeading = screen.getByText('Devices')
diff --git a/test/e2e/sidebar-click-opens-pane.test.tsx b/test/e2e/sidebar-click-opens-pane.test.tsx
index 1e64547f..16b8093f 100644
--- a/test/e2e/sidebar-click-opens-pane.test.tsx
+++ b/test/e2e/sidebar-click-opens-pane.test.tsx
@@ -103,9 +103,6 @@ function createStore(options: {
     } satisfies ServerSettingsPatch,
   )
   const localSettings = resolveLocalSettings({
-    panes: {
-      sessionOpenMode: options.sessionOpenMode ?? defaultSettings.panes.sessionOpenMode,
-    },
     sidebar: {
       sortMode: 'activity',
       showProjectBadges: true,
@@ -114,6 +111,9 @@ function createStore(options: {
       showNoninteractiveSessions: options.showNoninteractiveSessions ?? defaultSettings.sidebar.showNoninteractiveSessions,
       hideEmptySessions: false,
     },
+    panes: {
+      sessionOpenMode: options.sessionOpenMode ?? defaultSettings.panes.sessionOpenMode,
+    },
   })
 
   const projects = options.projects.map((project) => ({
diff --git a/test/e2e/sidebar-refresh-dom-stability.test.tsx b/test/e2e/sidebar-refresh-dom-stability.test.tsx
index bf0364d4..3de80645 100644
--- a/test/e2e/sidebar-refresh-dom-stability.test.tsx
+++ b/test/e2e/sidebar-refresh-dom-stability.test.tsx
@@ -341,4 +341,92 @@ describe('sidebar refresh DOM stability (e2e)', () => {
 
     expect(screen.getByRole('button', { name: /Stable A/i })).toBe(stableAButton)
   })
+
+  it('skips redundant session fetches when revision has not increased', async () => {
+    const initialProjects = [
+      {
+        projectPath: '/proj',
+        sessions: [
+          { provider: 'codex', sessionId: 's-1', projectPath: '/proj', lastActivityAt: 10, title: 'S1' },
+        ],
+      },
+    ]
+
+    fetchSidebarSessionsSnapshot.mockResolvedValue({
+      projects: initialProjects,
+      totalSessions: 1,
+      oldestIncludedTimestamp: 10,
+      oldestIncludedSessionId: 'codex:s-1',
+      hasMore: false,
+    })
+
+    const store = createStore({
+      sessions: {
+        projects: initialProjects,
+        activeSurface: 'sidebar',
+        lastLoadedAt: Date.now(),
+        totalSessions: 1,
+        oldestLoadedTimestamp: 10,
+        oldestLoadedSessionId: 'codex:s-1',
+        hasMore: false,
+        windows: {
+          sidebar: {
+            projects: initialProjects,
+            lastLoadedAt: Date.now(),
+            totalSessions: 1,
+            oldestLoadedTimestamp: 10,
+            oldestLoadedSessionId: 'codex:s-1',
+            hasMore: false,
+          },
+        },
+      },
+    })
+
+    render(
+      <Provider store={store}>
+        <App />
+      </Provider>,
+    )
+
+    act(() => {
+      wsMocks.isReady = true
+      wsMocks.serverInstanceId = 'srv-dedup'
+      broadcastWs({
+        type: 'ready',
+        timestamp: new Date().toISOString(),
+        serverInstanceId: 'srv-dedup',
+      })
+    })
+
+    await waitFor(() => {
+      expect(store.getState().connection.status).toBe('ready')
+    })
+
+    // First broadcast with revision 5 — should trigger fetch
+    act(() => {
+      broadcastWs({ type: 'sessions.changed', revision: 5 })
+    })
+
+    await waitFor(() => {
+      expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    })
+
+    // Same revision 5 again — should NOT trigger another fetch
+    act(() => {
+      broadcastWs({ type: 'sessions.changed', revision: 5 })
+    })
+
+    // Give time for any async dispatch
+    await act(async () => { await new Promise((r) => setTimeout(r, 50)) })
+    expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+
+    // Higher revision 6 — should trigger fetch
+    act(() => {
+      broadcastWs({ type: 'sessions.changed', revision: 6 })
+    })
+
+    await waitFor(() => {
+      expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(2)
+    })
+  })
 })
diff --git a/test/e2e/sidebar-search-flow.test.tsx b/test/e2e/sidebar-search-flow.test.tsx
index 3002271b..fe978ddb 100644
--- a/test/e2e/sidebar-search-flow.test.tsx
+++ b/test/e2e/sidebar-search-flow.test.tsx
@@ -49,6 +49,8 @@ function createDeferred<T>() {
 function createStore(options?: {
   projects?: ProjectGroup[]
   sessions?: Record<string, unknown>
+  tabs?: any[]
+  panes?: any
 }) {
   const projects = (options?.projects ?? []).map((project) => ({
     ...project,
@@ -90,10 +92,10 @@ function createStore(options?: {
         lastSavedAt: undefined,
       },
       tabs: {
-        tabs: [],
+        tabs: options?.tabs ?? [],
         activeTabId: null,
       },
-      panes: {
+      panes: options?.panes ?? {
         layouts: {},
         activePane: {},
         paneTitles: {},
@@ -141,6 +143,13 @@ function renderSidebar(store: ReturnType<typeof createStore>) {
   return { ...result, onNavigate }
 }
 
+function getSidebarSessionOrder(labels: string[]): string[] {
+  const list = screen.getByTestId('sidebar-session-list')
+  return Array.from(list.querySelectorAll('button'))
+    .map((button) => labels.find((label) => button.textContent?.includes(label)))
+    .filter((label): label is string => Boolean(label))
+}
+
 describe('sidebar search flow (e2e)', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -215,6 +224,163 @@ describe('sidebar search flow (e2e)', () => {
     expect(screen.getByText('Deploy Pipeline')).toBeInTheDocument()
   })
 
+  it('renders a preloaded requested search and dispatches it on mount without local typing', async () => {
+    const searchRequest = createDeferred<any>()
+    vi.mocked(mockSearchSessions).mockReturnValueOnce(searchRequest.promise)
+
+    const store = createStore({
+      sessions: {
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            query: 'prefilled',
+            searchTier: 'title',
+            projects: [],
+          },
+        },
+      },
+    })
+
+    renderSidebar(store)
+    await act(async () => {
+      vi.advanceTimersByTime(300)
+      await Promise.resolve()
+    })
+
+    expect(screen.getByPlaceholderText('Search...')).toHaveValue('prefilled')
+    expect(screen.getByRole('combobox', { name: /search tier/i })).toHaveValue('title')
+    expect(screen.getByLabelText('Clear search')).toBeInTheDocument()
+    expect(mockSearchSessions).toHaveBeenCalledWith(expect.objectContaining({
+      query: 'prefilled',
+      tier: 'title',
+    }))
+    expect(screen.getByTestId('search-loading')).toBeInTheDocument()
+
+    await act(async () => {
+      searchRequest.resolve({
+        results: [],
+        tier: 'title',
+        query: 'prefilled',
+        totalScanned: 0,
+      })
+      await Promise.resolve()
+    })
+  })
+
+  it('matches subdirectory leaves and only shows matching open-tab fallbacks without pinning them above newer server results', async () => {
+    const matchingFallbackSessionId = 'fallback-trycycle'
+    vi.mocked(mockSearchSessions)
+      .mockResolvedValueOnce({
+        results: [
+          {
+            sessionId: 'server-newer',
+            provider: 'codex',
+            projectPath: '/proj/server',
+            title: 'Newer Server Result',
+            matchedIn: 'title',
+            lastActivityAt: 3_000,
+            archived: false,
+          },
+          {
+            sessionId: 'server-leaf',
+            provider: 'codex',
+            projectPath: '/proj/code/trycycle',
+            cwd: '/proj/code/trycycle/server',
+            title: 'Routine work',
+            matchedIn: 'title',
+            lastActivityAt: 2_500,
+            archived: false,
+          },
+        ],
+        tier: 'title',
+        query: 'trycycle',
+        totalScanned: 8,
+      } as any)
+      .mockResolvedValueOnce({
+        results: [],
+        tier: 'title',
+        query: 'code',
+        totalScanned: 8,
+      } as any)
+
+    const store = createStore({
+      tabs: [{
+        id: 'tab-fallback',
+        title: 'Open Matching Tab',
+        mode: 'codex',
+        resumeSessionId: matchingFallbackSessionId,
+        createdAt: 1_000,
+      }],
+      panes: {
+        layouts: {
+          'tab-fallback': {
+            type: 'leaf',
+            id: 'pane-fallback',
+            content: {
+              kind: 'terminal',
+              mode: 'codex',
+              status: 'running',
+              createRequestId: 'req-fallback',
+              resumeSessionId: matchingFallbackSessionId,
+              initialCwd: '/tmp/code/trycycle',
+            },
+          },
+        },
+        activePane: {
+          'tab-fallback': 'pane-fallback',
+        },
+        paneTitles: {
+          'tab-fallback': {
+            'pane-fallback': 'Open Matching Tab',
+          },
+        },
+      },
+    })
+
+    renderSidebar(store)
+    await act(() => vi.advanceTimersByTime(100))
+
+    fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'trycycle' } })
+
+    await act(async () => {
+      vi.advanceTimersByTime(500)
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    expect(mockSearchSessions).toHaveBeenCalledWith(expect.objectContaining({
+      query: 'trycycle',
+      tier: 'title',
+    }))
+    expect(screen.getByText('Routine work')).toBeInTheDocument()
+    expect(screen.getByText('Newer Server Result')).toBeInTheDocument()
+    expect(screen.getByText('Open Matching Tab')).toBeInTheDocument()
+    expect(getSidebarSessionOrder([
+      'Newer Server Result',
+      'Routine work',
+      'Open Matching Tab',
+    ])).toEqual([
+      'Newer Server Result',
+      'Routine work',
+      'Open Matching Tab',
+    ])
+
+    fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'code' } })
+
+    await act(async () => {
+      vi.advanceTimersByTime(500)
+      await Promise.resolve()
+      await Promise.resolve()
+    })
+
+    expect(mockSearchSessions).toHaveBeenLastCalledWith(expect.objectContaining({
+      query: 'code',
+      tier: 'title',
+    }))
+    expect(screen.queryByText('Routine work')).not.toBeInTheDocument()
+    expect(screen.queryByText('Open Matching Tab')).not.toBeInTheDocument()
+  })
+
   it('deep-tier search shows title results first, then merged results after Phase 2', async () => {
     const phase1Deferred = createDeferred<any>()
     const phase2Deferred = createDeferred<any>()
@@ -397,6 +563,7 @@ describe('sidebar search flow (e2e)', () => {
   it('clearing search returns to browse mode', async () => {
     const phase1Deferred = createDeferred<any>()
     const phase2Deferred = createDeferred<any>()
+    const browseDeferred = createDeferred<any>()
     vi.mocked(mockSearchSessions)
       .mockReturnValueOnce(phase1Deferred.promise) // Phase 1
       .mockReturnValueOnce(phase2Deferred.promise) // Phase 2 (will hang)
@@ -412,7 +579,32 @@ describe('sidebar search flow (e2e)', () => {
       }],
     }]
 
-    vi.mocked(mockFetchSnapshot).mockResolvedValue({
+    vi.mocked(mockFetchSnapshot).mockReturnValue(browseDeferred.promise)
+
+    const store = createStore({
+      projects: browseProjects,
+      sessions: {
+        activeSurface: 'sidebar',
+        projects: browseProjects,
+        lastLoadedAt: 1_000,
+        windows: {
+          sidebar: {
+            projects: browseProjects,
+            lastLoadedAt: 1_000,
+            query: '',
+            searchTier: 'title',
+            appliedQuery: '',
+            appliedSearchTier: 'title',
+            loading: false,
+            hasMore: false,
+            oldestLoadedTimestamp: 1_000,
+            oldestLoadedSessionId: 'claude:session-browse',
+          },
+        },
+      },
+    })
+
+    browseDeferred.resolve({
       projects: browseProjects,
       totalSessions: 1,
       oldestIncludedTimestamp: 1_000,
@@ -420,8 +612,6 @@ describe('sidebar search flow (e2e)', () => {
       hasMore: false,
     })
 
-    const store = createStore({ projects: browseProjects })
-
     renderSidebar(store)
     await act(() => vi.advanceTimersByTime(100))
 
@@ -461,10 +651,24 @@ describe('sidebar search flow (e2e)', () => {
     const clearButton = screen.getByLabelText('Clear search')
     fireEvent.click(clearButton)
 
-    // Wait for browse re-fetch
+    // Wait for browse re-fetch to start while leaving it unresolved.
     await act(async () => {
       vi.advanceTimersByTime(500)
       await Promise.resolve()
+    })
+
+    expect(screen.queryByTestId('search-loading')).not.toBeInTheDocument()
+    expect(screen.queryByRole('combobox', { name: /search tier/i })).not.toBeInTheDocument()
+
+    await act(async () => {
+      browseDeferred.resolve({
+        projects: browseProjects,
+        totalSessions: 1,
+        oldestIncludedTimestamp: 1_000,
+        oldestIncludedSessionId: 'claude:session-browse',
+        hasMore: false,
+      })
+      await Promise.resolve()
       await Promise.resolve()
     })
 
diff --git a/test/e2e/terminal-file-link-same-tab.test.tsx b/test/e2e/terminal-file-link-same-tab.test.tsx
index 47806077..cef43934 100644
--- a/test/e2e/terminal-file-link-same-tab.test.tsx
+++ b/test/e2e/terminal-file-link-same-tab.test.tsx
@@ -104,7 +104,8 @@ vi.mock('@xterm/xterm', () => {
     })
     loadAddon = vi.fn()
     registerLinkProvider = vi.fn((provider: any) => {
-      if (this.paneId) {
+      // Store only the first registered provider (file path provider)
+      if (this.paneId && !linkProvidersByPaneId.has(this.paneId)) {
         linkProvidersByPaneId.set(this.paneId, provider)
       }
       return { dispose: vi.fn() }
diff --git a/test/e2e/terminal-url-context-menu.test.tsx b/test/e2e/terminal-url-context-menu.test.tsx
new file mode 100644
index 00000000..f905fa82
--- /dev/null
+++ b/test/e2e/terminal-url-context-menu.test.tsx
@@ -0,0 +1,348 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { configureStore } from '@reduxjs/toolkit'
+import { Provider } from 'react-redux'
+import tabsReducer from '@/store/tabsSlice'
+import panesReducer from '@/store/panesSlice'
+import sessionsReducer from '@/store/sessionsSlice'
+import connectionReducer from '@/store/connectionSlice'
+import { api } from '@/lib/api'
+import { isMacLike } from '@/lib/utils'
+import settingsReducer, { defaultSettings } from '@/store/settingsSlice'
+import PaneLayout from '@/components/panes/PaneLayout'
+import { ContextMenuProvider } from '@/components/context-menu/ContextMenuProvider'
+import { ContextIds } from '@/components/context-menu/context-menu-constants'
+import type { PaneNode } from '@/store/paneTypes'
+
+const wsMocks = {
+  send: vi.fn(),
+  connect: vi.fn().mockResolvedValue(undefined),
+  onMessage: vi.fn(() => vi.fn()),
+  onReconnect: vi.fn(() => vi.fn()),
+  setHelloExtensionProvider: vi.fn(),
+}
+
+vi.mock('@/lib/ws-client', () => ({
+  getWsClient: () => wsMocks,
+}))
+
+vi.mock('@/lib/api', () => ({
+  api: {
+    get: vi.fn().mockResolvedValue([]),
+    post: vi.fn().mockResolvedValue({}),
+    patch: vi.fn().mockResolvedValue({}),
+    put: vi.fn().mockResolvedValue({}),
+    delete: vi.fn().mockResolvedValue({}),
+  },
+}))
+
+vi.mock('@/lib/utils', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/utils')>('@/lib/utils')
+  return {
+    ...actual,
+    isMacLike: vi.fn(() => false),
+  }
+})
+
+vi.mock('@/lib/url-rewrite', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/url-rewrite')>('@/lib/url-rewrite')
+  return {
+    ...actual,
+    isLoopbackHostname: vi.fn((hostname: string) => {
+      if (hostname === window.location.hostname) return false
+      return actual.isLoopbackHostname(hostname)
+    }),
+  }
+})
+
+vi.mock('@/components/panes/FloatingActionButton', () => ({
+  default: () => null,
+}))
+
+vi.mock('@/components/panes/IntersectionDragOverlay', () => ({
+  default: () => null,
+}))
+
+vi.mock('@xterm/xterm', () => {
+  class MockTerminal {
+    cols = 80
+    rows = 24
+    options: Record<string, unknown> = {}
+    focus = vi.fn()
+
+    constructor() {}
+
+    open = vi.fn((element: HTMLElement) => {
+      const surface = document.createElement('div')
+      surface.setAttribute('data-testid', 'terminal-xterm-surface')
+      surface.tabIndex = -1
+      element.appendChild(surface)
+    })
+
+    loadAddon = vi.fn()
+    registerLinkProvider = vi.fn(() => ({ dispose: vi.fn() }))
+    write = vi.fn()
+    writeln = vi.fn()
+    clear = vi.fn()
+    reset = vi.fn()
+    selectAll = vi.fn()
+    scrollLines = vi.fn()
+    scrollToBottom = vi.fn()
+    select = vi.fn()
+    selectLines = vi.fn()
+    paste = vi.fn()
+    attachCustomKeyEventHandler = vi.fn()
+    getSelection = vi.fn(() => '')
+    onData = vi.fn(() => ({ dispose: vi.fn() }))
+    onTitleChange = vi.fn(() => ({ dispose: vi.fn() }))
+    dispose = vi.fn()
+    buffer = {
+      active: {
+        viewportY: 0,
+        getLine: vi.fn(() => null),
+      },
+    }
+  }
+
+  return { Terminal: MockTerminal }
+})
+
+vi.mock('@xterm/addon-fit', () => ({
+  FitAddon: class {
+    fit = vi.fn()
+  },
+}))
+
+vi.mock('@xterm/xterm/css/xterm.css', () => ({}))
+
+class MockResizeObserver {
+  observe = vi.fn()
+  disconnect = vi.fn()
+  unobserve = vi.fn()
+}
+
+function createTwoPaneLayout(): PaneNode {
+  return {
+    type: 'split',
+    id: 'split-1',
+    direction: 'horizontal',
+    sizes: [50, 50],
+    children: [
+      {
+        type: 'leaf',
+        id: 'pane-1',
+        content: {
+          kind: 'terminal',
+          terminalId: 'term-1',
+          createRequestId: 'req-term-1',
+          status: 'running',
+          mode: 'shell',
+          shell: 'system',
+        },
+      },
+      {
+        type: 'leaf',
+        id: 'pane-2',
+        content: {
+          kind: 'terminal',
+          terminalId: 'term-2',
+          createRequestId: 'req-term-2',
+          status: 'running',
+          mode: 'shell',
+          shell: 'system',
+        },
+      },
+    ],
+  }
+}
+
+function createStore(layout: PaneNode) {
+  return configureStore({
+    reducer: {
+      tabs: tabsReducer,
+      panes: panesReducer,
+      sessions: sessionsReducer,
+      connection: connectionReducer,
+      settings: settingsReducer,
+    },
+    middleware: (getDefaultMiddleware) =>
+      getDefaultMiddleware({ serializableCheck: false }),
+    preloadedState: {
+      tabs: {
+        tabs: [{
+          id: 'tab-1',
+          createRequestId: 'tab-1',
+          title: 'Tab One',
+          status: 'running',
+          mode: 'shell',
+          shell: 'system',
+          createdAt: 1,
+        }],
+        activeTabId: 'tab-1',
+        renameRequestTabId: null,
+      },
+      panes: {
+        layouts: { 'tab-1': layout },
+        activePane: { 'tab-1': 'pane-1' },
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+        refreshRequestsByPane: {},
+      },
+      sessions: {
+        projects: [],
+        expandedProjects: new Set<string>(),
+      },
+      connection: {
+        status: 'ready',
+        platform: 'linux',
+        availableClis: {},
+        featureFlags: {},
+      },
+      settings: {
+        settings: defaultSettings,
+        loaded: true,
+        lastSavedAt: null,
+      },
+    },
+  })
+}
+
+function renderFlow(store: ReturnType<typeof createStore>) {
+  return render(
+    <Provider store={store}>
+      <ContextMenuProvider
+        view="terminal"
+        onViewChange={() => {}}
+        onToggleSidebar={() => {}}
+        sidebarCollapsed={false}
+      >
+        <PaneLayout
+          tabId="tab-1"
+          defaultContent={{ kind: 'browser', url: '', devToolsOpen: false }}
+        />
+      </ContextMenuProvider>
+    </Provider>,
+  )
+}
+
+async function settleMenu() {
+  await act(async () => {
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
+  })
+}
+
+describe('terminal URL context menu items (e2e)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(isMacLike).mockReturnValue(false)
+    vi.mocked(api.get).mockResolvedValue([])
+    vi.stubGlobal('ResizeObserver', MockResizeObserver)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.unstubAllGlobals()
+  })
+
+  it('right-clicking a terminal pane with a hovered URL shows URL-specific menu items', async () => {
+    const store = createStore(createTwoPaneLayout())
+    const user = userEvent.setup()
+    const { container } = renderFlow(store)
+
+    // Wait for terminal to mount
+    const terminalWrapper = await waitFor(() => {
+      const el = container.querySelector('[data-pane-id="pane-1"][data-context="terminal"]')
+      expect(el).not.toBeNull()
+      return el as HTMLElement
+    })
+
+    // Simulate hover state by setting the data attribute
+    terminalWrapper.dataset.hoveredUrl = 'https://hovered.example.com/path'
+
+    // Find an element inside the terminal to right-click
+    const surface = terminalWrapper.querySelector('[data-testid="terminal-xterm-container"]') || terminalWrapper
+    await user.pointer({ target: surface, keys: '[MouseRight]' })
+    await settleMenu()
+
+    // URL-specific items should appear
+    expect(screen.getByRole('menu')).toBeInTheDocument()
+    expect(screen.getByRole('menuitem', { name: 'Open URL in pane' })).toBeInTheDocument()
+    expect(screen.getByRole('menuitem', { name: 'Open URL in new tab' })).toBeInTheDocument()
+    expect(screen.getByRole('menuitem', { name: 'Open in external browser' })).toBeInTheDocument()
+    expect(screen.getByRole('menuitem', { name: 'Copy URL' })).toBeInTheDocument()
+
+    // Standard terminal items should also be present
+    expect(screen.getByRole('menuitem', { name: 'Copy' })).toBeInTheDocument()
+    expect(screen.getByRole('menuitem', { name: 'Paste' })).toBeInTheDocument()
+  })
+
+  it('right-clicking a terminal pane without a hovered URL shows no URL-specific items', async () => {
+    const store = createStore(createTwoPaneLayout())
+    const user = userEvent.setup()
+    const { container } = renderFlow(store)
+
+    const terminalWrapper = await waitFor(() => {
+      const el = container.querySelector('[data-pane-id="pane-1"][data-context="terminal"]')
+      expect(el).not.toBeNull()
+      return el as HTMLElement
+    })
+
+    // No hoveredUrl set
+    const surface = terminalWrapper.querySelector('[data-testid="terminal-xterm-container"]') || terminalWrapper
+    await user.pointer({ target: surface, keys: '[MouseRight]' })
+    await settleMenu()
+
+    expect(screen.getByRole('menu')).toBeInTheDocument()
+    expect(screen.queryByRole('menuitem', { name: 'Open URL in pane' })).not.toBeInTheDocument()
+    expect(screen.queryByRole('menuitem', { name: 'Copy URL' })).not.toBeInTheDocument()
+
+    // Standard items should be present
+    expect(screen.getByRole('menuitem', { name: 'Copy' })).toBeInTheDocument()
+  })
+
+  it('selecting "Open URL in pane" creates a browser pane split', async () => {
+    const store = createStore(createTwoPaneLayout())
+    const user = userEvent.setup()
+    const { container } = renderFlow(store)
+
+    const terminalWrapper = await waitFor(() => {
+      const el = container.querySelector('[data-pane-id="pane-1"][data-context="terminal"]')
+      expect(el).not.toBeNull()
+      return el as HTMLElement
+    })
+
+    terminalWrapper.dataset.hoveredUrl = 'https://split.example.com'
+
+    const surface = terminalWrapper.querySelector('[data-testid="terminal-xterm-container"]') || terminalWrapper
+    await user.pointer({ target: surface, keys: '[MouseRight]' })
+    await settleMenu()
+
+    const openInPaneItem = screen.getByRole('menuitem', { name: 'Open URL in pane' })
+    await user.click(openInPaneItem)
+
+    // Check layout has been split
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      // The root should still be a split
+      expect(layout.type).toBe('split')
+      if (layout.type !== 'split') return
+
+      // One of the branches should now contain a browser pane with the URL
+      const findBrowserPane = (node: any): boolean => {
+        if (node.type === 'leaf' && node.content?.kind === 'browser' && node.content?.url === 'https://split.example.com') {
+          return true
+        }
+        if (node.type === 'split') {
+          return findBrowserPane(node.children[0]) || findBrowserPane(node.children[1])
+        }
+        return false
+      }
+      expect(findBrowserPane(layout)).toBe(true)
+    })
+  })
+})
diff --git a/test/e2e/terminal-url-link-click.test.tsx b/test/e2e/terminal-url-link-click.test.tsx
new file mode 100644
index 00000000..a45e13e1
--- /dev/null
+++ b/test/e2e/terminal-url-link-click.test.tsx
@@ -0,0 +1,353 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, waitFor, cleanup } from '@testing-library/react'
+import { Provider } from 'react-redux'
+import { configureStore } from '@reduxjs/toolkit'
+import TabContent from '@/components/TabContent'
+import tabsReducer from '@/store/tabsSlice'
+import panesReducer from '@/store/panesSlice'
+import settingsReducer, { defaultSettings } from '@/store/settingsSlice'
+import connectionReducer from '@/store/connectionSlice'
+import type { PaneNode, TerminalPaneContent } from '@/store/paneTypes'
+
+const wsMocks = vi.hoisted(() => ({
+  send: vi.fn(),
+  connect: vi.fn().mockResolvedValue(undefined),
+  onMessage: vi.fn().mockReturnValue(() => {}),
+  onReconnect: vi.fn().mockReturnValue(() => {}),
+  setHelloExtensionProvider: vi.fn(),
+}))
+
+const apiMocks = vi.hoisted(() => ({
+  get: vi.fn(async (path: string) => {
+    if (path === '/api/terminals') return []
+    throw new Error(`Unexpected api.get path: ${path}`)
+  }),
+}))
+
+vi.mock('@/lib/ws-client', () => ({
+  getWsClient: () => ({
+    send: wsMocks.send,
+    connect: wsMocks.connect,
+    onMessage: wsMocks.onMessage,
+    onReconnect: wsMocks.onReconnect,
+    setHelloExtensionProvider: wsMocks.setHelloExtensionProvider,
+  }),
+}))
+
+vi.mock('@/lib/api', () => ({
+  api: {
+    get: apiMocks.get,
+    post: vi.fn(),
+    patch: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn(),
+  },
+}))
+
+vi.mock('@/lib/terminal-themes', () => ({
+  getTerminalTheme: () => ({}),
+}))
+
+vi.mock('@/components/terminal/terminal-runtime', () => ({
+  createTerminalRuntime: () => ({
+    attachAddons: vi.fn(),
+    fit: vi.fn(),
+    findNext: vi.fn(() => false),
+    findPrevious: vi.fn(() => false),
+    clearDecorations: vi.fn(),
+    onDidChangeResults: vi.fn(() => ({ dispose: vi.fn() })),
+    dispose: vi.fn(),
+    webglActive: vi.fn(() => false),
+    suspendWebgl: vi.fn(() => false),
+    resumeWebgl: vi.fn(),
+  }),
+}))
+
+// Track URL link providers by pane ID (index 1 = URL provider, index 0 = file path provider)
+const urlLinkProvidersByPaneId = new Map<string, {
+  provideLinks: (line: number, callback: (links: any[] | undefined) => void) => void
+}>()
+
+const linkHandlersByPaneId = new Map<string, {
+  activate: (event: MouseEvent, uri: string) => void
+}>()
+
+vi.mock('@xterm/xterm', () => {
+  class MockTerminal {
+    options: Record<string, unknown> = {}
+    cols = 80
+    rows = 24
+    paneId: string | null = null
+    buffer = {
+      active: {
+        viewportY: 0,
+        getLine: vi.fn(() => ({
+          translateToString: () => 'Visit https://example.com/docs for more info',
+        })),
+      },
+    }
+    open = vi.fn((element: HTMLElement) => {
+      this.paneId = element.closest('[data-pane-id]')?.getAttribute('data-pane-id') ?? null
+      if (this.paneId && this.options.linkHandler) {
+        linkHandlersByPaneId.set(this.paneId, this.options.linkHandler as any)
+      }
+    })
+    loadAddon = vi.fn()
+    private providerCount = 0
+    registerLinkProvider = vi.fn((provider: any) => {
+      this.providerCount++
+      // Second provider is the URL provider
+      if (this.providerCount === 2 && this.paneId) {
+        urlLinkProvidersByPaneId.set(this.paneId, provider)
+      }
+      return { dispose: vi.fn() }
+    })
+    write = vi.fn()
+    writeln = vi.fn()
+    clear = vi.fn()
+    dispose = vi.fn()
+    onData = vi.fn(() => ({ dispose: vi.fn() }))
+    onTitleChange = vi.fn(() => ({ dispose: vi.fn() }))
+    attachCustomKeyEventHandler = vi.fn()
+    getSelection = vi.fn(() => '')
+    focus = vi.fn()
+    paste = vi.fn()
+    reset = vi.fn()
+    select = vi.fn()
+    selectLines = vi.fn()
+    scrollLines = vi.fn()
+    scrollToBottom = vi.fn()
+
+    constructor(opts?: Record<string, unknown>) {
+      if (opts) this.options = opts
+    }
+  }
+
+  return { Terminal: MockTerminal }
+})
+
+vi.mock('@xterm/xterm/css/xterm.css', () => ({}))
+
+class MockResizeObserver {
+  observe = vi.fn()
+  disconnect = vi.fn()
+  unobserve = vi.fn()
+}
+
+function createTerminalContent(createRequestId: string, terminalId: string): TerminalPaneContent {
+  return {
+    kind: 'terminal',
+    createRequestId,
+    status: 'running',
+    mode: 'shell',
+    shell: 'system',
+    terminalId,
+    initialCwd: '/tmp',
+  }
+}
+
+function createStore(opts?: { warnExternalLinks?: boolean }) {
+  const clickedPaneId = 'pane-clicked'
+  const layout: PaneNode = {
+    type: 'split',
+    id: 'split-root',
+    direction: 'vertical',
+    sizes: [45, 55],
+    children: [
+      {
+        type: 'leaf',
+        id: 'pane-left',
+        content: createTerminalContent('req-left', 'term-left'),
+      },
+      {
+        type: 'split',
+        id: 'split-right',
+        direction: 'horizontal',
+        sizes: [50, 50],
+        children: [
+          {
+            type: 'leaf',
+            id: 'pane-middle',
+            content: createTerminalContent('req-middle', 'term-middle'),
+          },
+          {
+            type: 'leaf',
+            id: clickedPaneId,
+            content: createTerminalContent('req-clicked', 'term-clicked'),
+          },
+        ],
+      },
+    ],
+  }
+
+  const settings = {
+    ...defaultSettings,
+    terminal: {
+      ...defaultSettings.terminal,
+      warnExternalLinks: opts?.warnExternalLinks ?? false,
+    },
+  }
+
+  return configureStore({
+    reducer: {
+      tabs: tabsReducer,
+      panes: panesReducer,
+      settings: settingsReducer,
+      connection: connectionReducer,
+    },
+    preloadedState: {
+      tabs: {
+        tabs: [{
+          id: 'tab-1',
+          createRequestId: 'req-left',
+          title: 'Shell',
+          status: 'running',
+          mode: 'shell',
+          shell: 'system',
+          terminalId: 'term-left',
+          createdAt: 1,
+        }],
+        activeTabId: 'tab-1',
+        renameRequestTabId: null,
+      },
+      panes: {
+        layouts: { 'tab-1': layout },
+        activePane: { 'tab-1': 'pane-left' },
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+        refreshRequestsByPane: {},
+      },
+      settings: {
+        settings,
+        loaded: true,
+      },
+      connection: {
+        status: 'ready',
+        platform: null,
+        availableClis: {},
+        featureFlags: {},
+      },
+    },
+  })
+}
+
+describe('terminal URL links open browser pane on the clicked pane branch without navigating tabs', () => {
+  beforeEach(() => {
+    apiMocks.get.mockClear()
+    wsMocks.send.mockClear()
+    wsMocks.connect.mockClear()
+    wsMocks.onMessage.mockClear()
+    wsMocks.onReconnect.mockClear()
+    wsMocks.setHelloExtensionProvider.mockClear()
+    urlLinkProvidersByPaneId.clear()
+    linkHandlersByPaneId.clear()
+    vi.stubGlobal('ResizeObserver', MockResizeObserver)
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.unstubAllGlobals()
+  })
+
+  it('clicking a URL in a nested terminal pane opens a browser pane on the same tab branch', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TabContent tabId="tab-1" />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(urlLinkProvidersByPaneId.has('pane-clicked')).toBe(true)
+    })
+
+    const clickedProvider = urlLinkProvidersByPaneId.get('pane-clicked')!
+    let links: any[] | undefined
+    clickedProvider.provideLinks(1, (provided) => {
+      links = provided
+    })
+
+    expect(links).toHaveLength(1)
+    expect(links![0].text).toBe('https://example.com/docs')
+
+    links![0].activate(new MouseEvent('click'))
+
+    await waitFor(() => {
+      expect(store.getState().tabs.tabs).toHaveLength(1)
+      expect(store.getState().tabs.activeTabId).toBe('tab-1')
+    })
+
+    const root = store.getState().panes.layouts['tab-1']
+    expect(root.type).toBe('split')
+    if (root.type !== 'split') throw new Error('expected root split layout')
+
+    expect(root.children[0]).toMatchObject({ type: 'leaf', id: 'pane-left' })
+
+    const rightBranch = root.children[1]
+    expect(rightBranch.type).toBe('split')
+    if (rightBranch.type !== 'split') throw new Error('expected right branch split layout')
+
+    expect(rightBranch.children[0]).toMatchObject({ type: 'leaf', id: 'pane-middle' })
+
+    const clickedBranch = rightBranch.children[1]
+    expect(clickedBranch.type).toBe('split')
+    if (clickedBranch.type !== 'split') throw new Error('expected clicked branch split layout')
+
+    expect(clickedBranch.children[0]).toMatchObject({ type: 'leaf', id: 'pane-clicked' })
+    expect(clickedBranch.children[1]).toMatchObject({
+      type: 'leaf',
+      content: {
+        kind: 'browser',
+        url: 'https://example.com/docs',
+        devToolsOpen: false,
+      },
+    })
+  })
+
+  it('OSC 8 link click in a nested pane opens browser pane (with warnExternalLinks disabled)', async () => {
+    const store = createStore({ warnExternalLinks: false })
+
+    render(
+      <Provider store={store}>
+        <TabContent tabId="tab-1" />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(linkHandlersByPaneId.has('pane-clicked')).toBe(true)
+    })
+
+    const handler = linkHandlersByPaneId.get('pane-clicked')!
+    handler.activate(new MouseEvent('click'), 'https://osc8.example.com/path')
+
+    await waitFor(() => {
+      expect(store.getState().tabs.tabs).toHaveLength(1)
+    })
+
+    const root = store.getState().panes.layouts['tab-1']
+    expect(root.type).toBe('split')
+    if (root.type !== 'split') throw new Error('expected root split layout')
+
+    const rightBranch = root.children[1]
+    expect(rightBranch.type).toBe('split')
+    if (rightBranch.type !== 'split') throw new Error('expected right branch split layout')
+
+    const clickedBranch = rightBranch.children[1]
+    expect(clickedBranch.type).toBe('split')
+    if (clickedBranch.type !== 'split') throw new Error('expected clicked branch split layout')
+
+    expect(clickedBranch.children[0]).toMatchObject({ type: 'leaf', id: 'pane-clicked' })
+    expect(clickedBranch.children[1]).toMatchObject({
+      type: 'leaf',
+      content: {
+        kind: 'browser',
+        url: 'https://osc8.example.com/path',
+        devToolsOpen: false,
+      },
+    })
+  })
+})
diff --git a/test/fixtures/sessions/inline-stop-hook-progress.jsonl b/test/fixtures/sessions/inline-stop-hook-progress.jsonl
new file mode 100644
index 00000000..ff9f3ce4
--- /dev/null
+++ b/test/fixtures/sessions/inline-stop-hook-progress.jsonl
@@ -0,0 +1,5 @@
+{"type":"user","message":"Help me with a task","uuid":"u-001","parentUuid":null,"timestamp":"2026-01-30T10:00:00.000Z"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Sure, I can help."}]},"uuid":"a-002","parentUuid":"u-001","timestamp":"2026-01-30T10:00:01.000Z"}
+{"type":"progress","data":{"type":"hook_progress","hookEvent":"Stop","hookName":"Stop","command":"echo done"},"toolUseID":"tool-001","parentToolUseID":"tool-001","uuid":"p-003","parentUuid":"a-002","timestamp":"2026-01-30T10:00:02.000Z"}
+{"type":"system","subtype":"stop_hook_summary","hookCount":1,"hookInfos":[{"command":"echo done"}],"hookErrors":[],"preventedContinuation":false,"stopReason":"","hasOutput":false,"level":"suggestion","uuid":"s-004","parentUuid":"p-003","toolUseID":"tool-001","timestamp":"2026-01-30T10:00:03.000Z"}
+{"type":"system","subtype":"turn_duration","durationMs":2500,"uuid":"td-005","parentUuid":"s-004","timestamp":"2026-01-30T10:00:04.000Z"}
diff --git a/test/fixtures/sessions/sibling-stop-hook-progress.jsonl b/test/fixtures/sessions/sibling-stop-hook-progress.jsonl
new file mode 100644
index 00000000..78348d12
--- /dev/null
+++ b/test/fixtures/sessions/sibling-stop-hook-progress.jsonl
@@ -0,0 +1,5 @@
+{"type":"user","message":"Help me with a task","uuid":"u-001","parentUuid":null,"timestamp":"2026-01-30T10:00:00.000Z"}
+{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Sure, I can help."}]},"uuid":"a-002","parentUuid":"u-001","timestamp":"2026-01-30T10:00:01.000Z"}
+{"type":"progress","data":{"type":"hook_progress","hookEvent":"Stop","hookName":"Stop","command":"echo done"},"toolUseID":"tool-001","parentToolUseID":"tool-001","uuid":"p-003","parentUuid":"a-002","timestamp":"2026-01-30T10:00:02.000Z"}
+{"type":"system","subtype":"stop_hook_summary","hookCount":1,"hookInfos":[{"command":"echo done"}],"hookErrors":[],"preventedContinuation":false,"stopReason":"","hasOutput":false,"level":"suggestion","uuid":"s-004","parentUuid":"a-002","toolUseID":"tool-001","timestamp":"2026-01-30T10:00:03.000Z"}
+{"type":"system","subtype":"turn_duration","durationMs":2500,"uuid":"td-005","parentUuid":"s-004","timestamp":"2026-01-30T10:00:04.000Z"}
diff --git a/test/integration/client/editor-pane.test.tsx b/test/integration/client/editor-pane.test.tsx
index c34bd73d..bb6d7913 100644
--- a/test/integration/client/editor-pane.test.tsx
+++ b/test/integration/client/editor-pane.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { render, screen, waitFor, cleanup } from '@testing-library/react'
+import { render, screen, waitFor, cleanup, fireEvent } from '@testing-library/react'
 import userEvent from '@testing-library/user-event'
 import { Provider } from 'react-redux'
 import { configureStore } from '@reduxjs/toolkit'
@@ -176,6 +176,13 @@ const createTestStore = () =>
     },
   })
 
+async function selectEditorFromPicker(user: ReturnType<typeof userEvent.setup>) {
+  await user.click(screen.getByRole('button', { name: /add pane/i }))
+  const picker = await screen.findByRole('toolbar', { name: /pane type picker/i })
+  await user.click(screen.getByRole('button', { name: 'Editor' }))
+  fireEvent.transitionEnd(picker)
+}
+
 describe('Editor Pane Integration', () => {
   let store: ReturnType<typeof createTestStore>
   let fetchRouter: ReturnType<typeof createRoutedFetch>
@@ -214,8 +221,7 @@ describe('Editor Pane Integration', () => {
     vi.restoreAllMocks()
   })
 
-  // Skip: JSDOM doesn't fire CSS transitionend events needed for PanePicker selection
-  it.skip('can add editor pane via FAB', async () => {
+  it('can add editor pane via FAB', async () => {
     const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime })
 
     // Initialize with terminal
@@ -235,11 +241,7 @@ describe('Editor Pane Integration', () => {
       </Provider>
     )
 
-    // Click FAB to add picker pane
-    await user.click(screen.getByRole('button', { name: /add pane/i }))
-
-    // Select Editor from picker (using keyboard shortcut for reliability)
-    await user.keyboard('e')
+    await selectEditorFromPicker(user)
 
     // Should see empty state with Open File button
     await waitFor(() => {
@@ -251,8 +253,7 @@ describe('Editor Pane Integration', () => {
     expect(state.layouts['tab-1'].type).toBe('split')
   })
 
-  // Skip: JSDOM doesn't fire CSS transitionend events needed for PanePicker selection
-  it.skip('displays editor toolbar with path input', async () => {
+  it('displays editor toolbar with path input', async () => {
     const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime })
 
     store.dispatch(
@@ -271,9 +272,7 @@ describe('Editor Pane Integration', () => {
       </Provider>
     )
 
-    // Add editor pane via picker
-    await user.click(screen.getByRole('button', { name: /add pane/i }))
-    await user.keyboard('e')
+    await selectEditorFromPicker(user)
 
     // Should see the path input
     await waitFor(() => {
@@ -600,8 +599,7 @@ describe('Editor Pane Integration', () => {
     consoleSpy.mockRestore()
   })
 
-  // Skip: JSDOM doesn't fire CSS transitionend events needed for PanePicker selection
-  it.skip('integrates with terminal and editor panes in split view', async () => {
+  it('integrates with terminal and editor panes in split view', async () => {
     const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime })
 
     // Start with a terminal
@@ -630,10 +628,7 @@ describe('Editor Pane Integration', () => {
       }
     })
 
-    // Add an editor pane
-    await user.click(screen.getByRole('button', { name: /add pane/i }))
-    // Click the Editor option directly (keyboard shortcuts require transition animation)
-    await user.click(screen.getByText('Editor'))
+    await selectEditorFromPicker(user)
 
     // Both terminal and editor should be visible
     await waitFor(() => {
diff --git a/test/integration/server/files-api.test.ts b/test/integration/server/files-api.test.ts
index d401659b..10dee7bc 100644
--- a/test/integration/server/files-api.test.ts
+++ b/test/integration/server/files-api.test.ts
@@ -296,7 +296,7 @@ describe('Files API Integration', () => {
     // from WSL_WINDOWS_SYS32 via a regex that matches the first single-letter path
     // component. This only works reliably on Linux where temp paths lack single-letter
     // components (macOS /var/folders/.../T/ confuses the regex).
-    it.skipIf(process.platform !== 'linux')('supports Windows drive prefixes when running in WSL', async () => {
+    it('supports Windows drive prefixes when running in WSL', async () => {
       const originalWslDistro = process.env.WSL_DISTRO_NAME
       const originalWslSys32 = process.env.WSL_WINDOWS_SYS32
       const originalPlatform = process.platform
@@ -386,7 +386,7 @@ describe('Files API Integration', () => {
     })
 
     // WSL path simulation only works on Linux; macOS temp paths confuse the mount prefix regex
-    it.skipIf(process.platform !== 'linux')('validates Windows drive paths when running in WSL', async () => {
+    it('validates Windows drive paths when running in WSL', async () => {
       const originalWslDistro = process.env.WSL_DISTRO_NAME
       const originalWslSys32 = process.env.WSL_WINDOWS_SYS32
       const originalPlatform = process.platform
diff --git a/test/integration/server/logger.separation.test.ts b/test/integration/server/logger.separation.test.ts
index 9f40444c..6dc8c0ea 100644
--- a/test/integration/server/logger.separation.test.ts
+++ b/test/integration/server/logger.separation.test.ts
@@ -18,14 +18,6 @@ const __dirname = path.dirname(__filename)
 const REPO_ROOT = path.resolve(__dirname, '../../..')
 const require = createRequire(import.meta.url)
 let TSX_CLI: string | undefined
-const HAS_TSX_CLI = (() => {
-  try {
-    require.resolve('tsx/cli')
-    return true
-  } catch {
-    return false
-  }
-})()
 const DEFAULT_TEST_TIMEOUT_MS = 120_000
 const ANSI_ESCAPE_PATTERN = /\u001b\[[0-9;]*m/g
 const SOURCE_LOGGER_PROBE = [
@@ -129,7 +121,7 @@ async function startDistLoggerProcess(env: NodeJS.ProcessEnv) {
 }
 
 describe('debug log separation', () => {
-  it.skipIf(!HAS_TSX_CLI)(
+  it(
     'dist and source launches choose different mode-specific filenames',
     { timeout: DEFAULT_TEST_TIMEOUT_MS },
     async () => {
@@ -160,7 +152,7 @@ describe('debug log separation', () => {
     },
   )
 
-  it.skipIf(!HAS_TSX_CLI)(
+  it(
     'concurrent launches with the same mode keep separate files',
     { timeout: DEFAULT_TEST_TIMEOUT_MS },
     async () => {
@@ -191,7 +183,7 @@ describe('debug log separation', () => {
     },
   )
 
-  it.skipIf(!HAS_TSX_CLI)(
+  it(
     'explicit instance settings are respected across launch modes',
     { timeout: DEFAULT_TEST_TIMEOUT_MS },
     async () => {
@@ -220,7 +212,7 @@ describe('debug log separation', () => {
     },
   )
 
-  it.skipIf(!HAS_TSX_CLI)(
+  it(
     'startup logs include resolved debug destination details',
     { timeout: DEFAULT_TEST_TIMEOUT_MS },
     async () => {
diff --git a/test/integration/server/platform-api.test.ts b/test/integration/server/platform-api.test.ts
index eaeedc1e..14e7b36a 100644
--- a/test/integration/server/platform-api.test.ts
+++ b/test/integration/server/platform-api.test.ts
@@ -195,6 +195,25 @@ describe('Platform API', () => {
       expect(res.body.updateCheck).toEqual({ hasUpdate: false })
     })
 
+    it('calls checkForUpdate only once for rapid successive requests', async () => {
+      const spy = vi.fn().mockResolvedValue({ hasUpdate: false })
+      const cacheApp = express()
+      cacheApp.use(express.json())
+      cacheApp.use('/api', (_req, _res, next) => next())
+      cacheApp.use('/api', createPlatformRouter({
+        ...mockDeps,
+        checkForUpdate: spy,
+      }))
+
+      await request(cacheApp).get('/api/version')
+      await request(cacheApp).get('/api/version')
+      await request(cacheApp).get('/api/version')
+
+      // The router calls checkForUpdate each time (caching is at the wiring layer)
+      // This test documents that the router itself doesn't cache
+      expect(spy).toHaveBeenCalledTimes(3)
+    })
+
     it('returns null updateCheck when check fails', async () => {
       // Create a separate app with a failing checkForUpdate
       const failApp = express()
diff --git a/test/integration/server/session-directory-router.test.ts b/test/integration/server/session-directory-router.test.ts
index 67cfbb7e..4a5c327f 100644
--- a/test/integration/server/session-directory-router.test.ts
+++ b/test/integration/server/session-directory-router.test.ts
@@ -292,6 +292,42 @@ describe('search tiers through the HTTP route (full round-trip)', () => {
     expect(res.body.items[0].matchedIn).toBe('title')
   })
 
+  it('matches a project-path leaf through the HTTP contract and rejects ancestor-only path text', async () => {
+    createAppWithProjects([{
+      projectPath: '/home/user/code/trycycle',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-1',
+        projectPath: '/home/user/code/trycycle',
+        cwd: '/home/user/code/trycycle/server',
+        lastActivityAt: 100,
+        title: 'Routine work',
+      }],
+    }])
+
+    const leafResponse = await request(app)
+      .get('/api/session-directory?priority=visible&query=trycycle&tier=title')
+      .set('x-auth-token', TEST_AUTH_TOKEN)
+
+    expect(leafResponse.status).toBe(200)
+    expect(leafResponse.body.items).toHaveLength(1)
+    expect(leafResponse.body.items[0]).toMatchObject({
+      sessionId: 'session-1',
+      matchedIn: 'title',
+      snippet: 'trycycle',
+      projectPath: '/home/user/code/trycycle',
+      cwd: '/home/user/code/trycycle/server',
+    })
+    expect(leafResponse.body.items[0]).not.toHaveProperty('matchedPath')
+
+    const ancestorResponse = await request(app)
+      .get('/api/session-directory?priority=visible&query=code&tier=title')
+      .set('x-auth-token', TEST_AUTH_TOKEN)
+
+    expect(ancestorResponse.status).toBe(200)
+    expect(ancestorResponse.body.items).toHaveLength(0)
+  })
+
   it('userMessages tier searches JSONL user messages', async () => {
     const sessionFile = path.join(tempDir, 'session-1.jsonl')
     await fsp.writeFile(sessionFile, [
diff --git a/test/server/ws-handshake-snapshot.test.ts b/test/server/ws-handshake-snapshot.test.ts
index e384564d..cca48469 100644
--- a/test/server/ws-handshake-snapshot.test.ts
+++ b/test/server/ws-handshake-snapshot.test.ts
@@ -43,6 +43,9 @@ class FakeRegistry {
   detach() {
     return true
   }
+  list() {
+    return []
+  }
 }
 
 function waitForMessage(ws: WebSocket, predicate: (msg: any) => boolean, timeoutMs = 2000): Promise<any> {
@@ -275,6 +278,64 @@ describe('ws handshake snapshot', () => {
     }
   })
 
+  it('includes a bootId in the ready message that differs from serverInstanceId', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+    try {
+      await new Promise<void>((resolve) => ws.on('open', () => resolve()))
+
+      const readyMsg = await waitForReady(ws, 10_000)
+      expect(readyMsg).toHaveProperty('bootId')
+      expect(typeof readyMsg.bootId).toBe('string')
+      expect(readyMsg.bootId.length).toBeGreaterThan(0)
+      // bootId should be different from serverInstanceId (boot is ephemeral, instance is persistent)
+      expect(readyMsg.bootId).not.toBe(readyMsg.serverInstanceId)
+    } finally {
+      await closeWs(ws)
+    }
+  })
+
+  it('sends the same bootId to multiple clients within the same process', async () => {
+    const ws1 = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+    const ws2 = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+    try {
+      await Promise.all([
+        new Promise<void>((resolve) => ws1.on('open', () => resolve())),
+        new Promise<void>((resolve) => ws2.on('open', () => resolve())),
+      ])
+
+      const [ready1, ready2] = await Promise.all([
+        waitForReady(ws1, 10_000),
+        waitForReady(ws2, 10_000),
+      ])
+
+      expect(ready1.bootId).toBe(ready2.bootId)
+    } finally {
+      await closeWs(ws1)
+      await closeWs(ws2)
+    }
+  })
+
+  it('sends terminal inventory in handshake snapshot', async () => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+    try {
+      await new Promise<void>((resolve) => ws.on('open', () => resolve()))
+
+      const inventoryPromise = waitForMessage(ws, (m) => m.type === 'terminal.inventory', 10_000)
+      await waitForReady(ws, 10_000)
+
+      const inventory = await inventoryPromise
+      expect(inventory).toHaveProperty('type', 'terminal.inventory')
+      expect(inventory).toHaveProperty('bootId')
+      expect(Array.isArray(inventory.terminals)).toBe(true)
+      expect(Array.isArray(inventory.terminalMeta)).toBe(true)
+    } finally {
+      await closeWs(ws)
+    }
+  })
+
   it('still omits websocket sessions payloads when no projects exist', async () => {
     snapshot = {
       ...snapshot,
diff --git a/test/server/ws-terminal-create-session-repair.test.ts b/test/server/ws-terminal-create-session-repair.test.ts
index af6cac76..ec1641a1 100644
--- a/test/server/ws-terminal-create-session-repair.test.ts
+++ b/test/server/ws-terminal-create-session-repair.test.ts
@@ -826,6 +826,57 @@ describe('terminal.create session repair wait', () => {
     }
   })
 
+  it('does not skip resume for healthy sessions with inline-progress resume issue', async () => {
+    // Simulate: getResult returns a cached result with resumeIssue
+    sessionRepairService.result = {
+      sessionId: VALID_SESSION_ID,
+      filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+      status: 'healthy',
+      chainDepth: 5,
+      orphanCount: 0,
+      fileSize: 500,
+      messageCount: 5,
+      resumeIssue: 'inline_stop_hook_progress',
+    }
+
+    // waitForSession should still be called because the cached result has a resume issue
+    // After repair, it returns the clean result
+    sessionRepairService.waitForSessionResult = {
+      sessionId: VALID_SESSION_ID,
+      filePath: `/tmp/${VALID_SESSION_ID}.jsonl`,
+      status: 'healthy',
+      chainDepth: 5,
+      orphanCount: 0,
+      fileSize: 500,
+      messageCount: 5,
+    }
+
+    const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
+
+    try {
+      await new Promise<void>((resolve) => ws.on('open', () => resolve()))
+      await waitForReady(ws)
+
+      const requestId = 'resume-inline-progress-1'
+      const createdPromise = waitForCreated(ws, requestId, 3000)
+      ws.send(JSON.stringify({
+        type: 'terminal.create',
+        requestId,
+        mode: 'claude',
+        resumeSessionId: VALID_SESSION_ID,
+      }))
+
+      const created = await createdPromise
+
+      // Resume should proceed (not be dropped)
+      expect(created.effectiveResumeSessionId).toBe(VALID_SESSION_ID)
+      // waitForSession should have been called despite cached result
+      expect(sessionRepairService.waitForSessionCalls).toContain(VALID_SESSION_ID)
+    } finally {
+      await closeWebSocket(ws)
+    }
+  })
+
   it('passes non-UUID resumeSessionId through to create and skips session repair wait', async () => {
     const ws = new WebSocket(`ws://127.0.0.1:${port}/ws`)
 
diff --git a/test/unit/client/components/SettingsView.behavior.test.tsx b/test/unit/client/components/SettingsView.behavior.test.tsx
index 1a722827..aa8e34e2 100644
--- a/test/unit/client/components/SettingsView.behavior.test.tsx
+++ b/test/unit/client/components/SettingsView.behavior.test.tsx
@@ -32,6 +32,15 @@ function getSlider(predicate: (slider: HTMLElement) => boolean) {
   return screen.getAllByRole('slider').find((slider) => predicate(slider))!
 }
 
+function getSettingsSection(title: string) {
+  const heading = screen.getByRole('heading', { name: title })
+  const section = heading.parentElement?.parentElement
+  if (!section) {
+    throw new Error(`Could not find settings section for "${title}"`)
+  }
+  return section
+}
+
 describe('SettingsView behavior sections', () => {
   describe('additional settings interactions', () => {
     it('updates terminal theme locally without calling /api/settings', async () => {
@@ -414,11 +423,13 @@ describe('SettingsView behavior sections', () => {
       renderSettingsView(store)
       switchSettingsTab('Workspace')
 
-      expect(screen.getAllByText('New tab').length).toBeGreaterThan(0)
-      expect(screen.getByText('Close tab')).toBeInTheDocument()
-      expect(screen.getByText('Previous tab')).toBeInTheDocument()
-      expect(screen.getByText('Next tab')).toBeInTheDocument()
-      expect(screen.getByText('Newline')).toBeInTheDocument()
+      const keyboardShortcuts = within(getSettingsSection('Keyboard shortcuts'))
+
+      expect(keyboardShortcuts.getByText('New tab')).toBeInTheDocument()
+      expect(keyboardShortcuts.getByText('Close tab')).toBeInTheDocument()
+      expect(keyboardShortcuts.getByText('Previous tab')).toBeInTheDocument()
+      expect(keyboardShortcuts.getByText('Next tab')).toBeInTheDocument()
+      expect(keyboardShortcuts.getByText('Newline')).toBeInTheDocument()
     })
 
     it('displays keyboard shortcut keys', () => {
@@ -426,11 +437,13 @@ describe('SettingsView behavior sections', () => {
       renderSettingsView(store)
       switchSettingsTab('Workspace')
 
-      expect(screen.getAllByText('Alt').length).toBeGreaterThan(0)
-      expect(screen.getAllByText('Ctrl').length).toBeGreaterThan(0)
-      expect(screen.getAllByText('Shift').length).toBeGreaterThan(0)
-      expect(screen.getAllByText('[').length).toBeGreaterThan(0)
-      expect(screen.getAllByText(']').length).toBeGreaterThan(0)
+      const keyboardShortcuts = within(getSettingsSection('Keyboard shortcuts'))
+
+      expect(keyboardShortcuts.getAllByText('Alt').length).toBeGreaterThan(0)
+      expect(keyboardShortcuts.getAllByText('Ctrl').length).toBeGreaterThan(0)
+      expect(keyboardShortcuts.getAllByText('Shift').length).toBeGreaterThan(0)
+      expect(keyboardShortcuts.getAllByText('[').length).toBeGreaterThan(0)
+      expect(keyboardShortcuts.getAllByText(']').length).toBeGreaterThan(0)
     })
   })
 
diff --git a/test/unit/client/components/Sidebar.dom-stability.test.tsx b/test/unit/client/components/Sidebar.dom-stability.test.tsx
index f12dc4f1..b55b82ca 100644
--- a/test/unit/client/components/Sidebar.dom-stability.test.tsx
+++ b/test/unit/client/components/Sidebar.dom-stability.test.tsx
@@ -7,7 +7,10 @@ import settingsReducer, { defaultSettings } from '@/store/settingsSlice'
 import tabsReducer from '@/store/tabsSlice'
 import panesReducer from '@/store/panesSlice'
 import connectionReducer from '@/store/connectionSlice'
-import sessionsReducer, { setSessionWindowData } from '@/store/sessionsSlice'
+import sessionsReducer, {
+  commitSessionWindowReplacement,
+  commitSessionWindowVisibleRefresh,
+} from '@/store/sessionsSlice'
 import sessionActivityReducer from '@/store/sessionActivitySlice'
 import extensionsReducer from '@/store/extensionsSlice'
 import codexActivityReducer from '@/store/codexActivitySlice'
@@ -128,7 +131,7 @@ describe('Sidebar DOM stability', () => {
     const store = createSidebarStore()
 
     act(() => {
-      store.dispatch(setSessionWindowData({
+      store.dispatch(commitSessionWindowReplacement({
         surface: 'sidebar',
         projects: [
           {
@@ -152,7 +155,7 @@ describe('Sidebar DOM stability', () => {
     const stableBButton = screen.getByRole('button', { name: /Stable B/i })
 
     act(() => {
-      store.dispatch(setSessionWindowData({
+      store.dispatch(commitSessionWindowVisibleRefresh({
         surface: 'sidebar',
         projects: [
           {
diff --git a/test/unit/client/components/Sidebar.perf-audit.test.tsx b/test/unit/client/components/Sidebar.perf-audit.test.tsx
index da48599b..fd4eccf1 100644
--- a/test/unit/client/components/Sidebar.perf-audit.test.tsx
+++ b/test/unit/client/components/Sidebar.perf-audit.test.tsx
@@ -1,6 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { render, screen, cleanup } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
 import { Provider } from 'react-redux'
 import { configureStore } from '@reduxjs/toolkit'
 import Sidebar from '@/components/Sidebar'
@@ -94,6 +93,31 @@ describe('Sidebar perf audit milestone', () => {
           wsSnapshotReceived: false,
           isLoading: false,
           error: null,
+          activeSurface: 'sidebar',
+          windows: {
+            sidebar: {
+              projects: [
+                {
+                  projectPath: '/tmp/project-alpha',
+                  sessions: [
+                    {
+                      provider: 'claude',
+                      sessionId: '00000000-0000-4000-8000-000000000999',
+                      title: 'alpha project session',
+                      projectPath: '/tmp/project-alpha',
+                      lastActivityAt: 1_000,
+                      cwd: '/tmp/project-alpha',
+                    },
+                  ],
+                },
+              ],
+              lastLoadedAt: 1_000,
+              query: 'alpha',
+              searchTier: 'title',
+              appliedQuery: 'alpha',
+              appliedSearchTier: 'title',
+            },
+          },
         },
       },
     })
@@ -104,9 +128,6 @@ describe('Sidebar perf audit milestone', () => {
       </Provider>,
     )
 
-    const user = userEvent.setup()
-    await user.type(screen.getByPlaceholderText('Search...'), 'alpha')
-
     expect(await screen.findByText(/alpha project session/i)).toBeVisible()
     expect(bridge.snapshot().milestones['sidebar.search_results_visible']).toBeTypeOf('number')
   })
diff --git a/test/unit/client/components/Sidebar.test.tsx b/test/unit/client/components/Sidebar.test.tsx
index 58e31af9..3f9793fd 100644
--- a/test/unit/client/components/Sidebar.test.tsx
+++ b/test/unit/client/components/Sidebar.test.tsx
@@ -8,7 +8,10 @@ import settingsReducer, { defaultSettings } from '@/store/settingsSlice'
 import tabsReducer from '@/store/tabsSlice'
 import panesReducer from '@/store/panesSlice'
 import connectionReducer from '@/store/connectionSlice'
-import sessionsReducer from '@/store/sessionsSlice'
+import sessionsReducer, {
+  commitSessionWindowReplacement,
+  setSessionWindowLoading,
+} from '@/store/sessionsSlice'
 import sessionActivityReducer from '@/store/sessionActivitySlice'
 import extensionsReducer from '@/store/extensionsSlice'
 import codexActivityReducer, { type CodexActivityState } from '@/store/codexActivitySlice'
@@ -63,6 +66,16 @@ const sessionId = (label: string) => {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`
 }
 
+function createDeferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason?: unknown) => void
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}
+
 function createTestStore(options?: {
   projects?: ProjectGroup[]
   sessions?: Record<string, unknown>
@@ -85,9 +98,9 @@ function createTestStore(options?: {
   serverInstanceId?: string
   sortMode?: 'recency' | 'activity' | 'project'
   showProjectBadges?: boolean
+  sessionOpenMode?: 'tab' | 'split'
   sessionActivity?: Record<string, number>
   codexActivity?: Partial<CodexActivityState>
-  sessionOpenMode?: 'tab' | 'split'
 }) {
   const projects = (options?.projects ?? []).map((project) => ({
     ...project,
@@ -141,16 +154,16 @@ function createTestStore(options?: {
       settings: {
         settings: {
           ...defaultSettings,
-          panes: {
-            ...defaultSettings.panes,
-            sessionOpenMode: options?.sessionOpenMode ?? defaultSettings.panes.sessionOpenMode,
-          },
           sidebar: {
             ...defaultSettings.sidebar,
             sortMode: options?.sortMode ?? 'activity',
             showProjectBadges: options?.showProjectBadges ?? true,
             hideEmptySessions: false,
           },
+          panes: {
+            ...defaultSettings.panes,
+            sessionOpenMode: options?.sessionOpenMode ?? defaultSettings.panes.sessionOpenMode,
+          },
         },
         loaded: true,
         lastSavedAt: undefined,
@@ -253,10 +266,18 @@ function triggerNearBottomScroll(
   fireEvent.scroll(node)
 }
 
+function getSidebarSessionOrder(labels: string[]): string[] {
+  const list = screen.getByTestId('sidebar-session-list')
+  return Array.from(list.querySelectorAll('button'))
+    .map((button) => labels.find((label) => button.textContent?.includes(label)))
+    .filter((label): label is string => Boolean(label))
+}
+
 describe('Sidebar Component - Session-Centric Display', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     vi.useFakeTimers()
+    vi.mocked(mockSearchSessions).mockReset()
     mockFetchSidebarSessionsSnapshot.mockReset()
     mockFetchSidebarSessionsSnapshot.mockResolvedValue({ projects: [] })
     mockGetTerminalDirectoryPage.mockReset()
@@ -1364,14 +1385,7 @@ describe('Sidebar Component - Session-Centric Display', () => {
       expect(state.tabs.activeTabId).toBe('existing-tab-id')
     })
 
-    // Note: Tests for running sessions require complex WebSocket mocking that is currently
-    // broken in the test setup. The implementation is verified to be correct through:
-    // 1. Code review - handleItemClick checks for existing tab before creating new one
-    // 2. The non-running session test passes, which uses the same pattern
-    // 3. Manual testing
-    //
-    // TODO: Fix WebSocket mock to properly simulate terminal.list responses with fake timers
-    it.skip('switches to existing tab when clicking running session that has a tab', async () => {
+    it('switches to existing tab when clicking running session that has a tab', async () => {
       const projects: ProjectGroup[] = [
         {
           projectPath: '/home/user/project',
@@ -1407,10 +1421,38 @@ describe('Sidebar Component - Session-Centric Display', () => {
           id: 'existing-tab-for-terminal',
           terminalId: 'running-terminal-id',
           mode: 'claude' as const,
+          resumeSessionId: sessionId('session-running'),
         },
       ]
 
-      const store = createTestStore({ projects, tabs: existingTabs, activeTabId: null, sortMode: 'activity' })
+      const panes = {
+        layouts: {
+          'existing-tab-for-terminal': {
+            type: 'leaf',
+            id: 'pane-running',
+            content: {
+              kind: 'terminal',
+              mode: 'claude',
+              createRequestId: 'req-running',
+              status: 'running',
+              terminalId: 'running-terminal-id',
+              resumeSessionId: sessionId('session-running'),
+            },
+          },
+        },
+        activePane: {
+          'existing-tab-for-terminal': 'pane-running',
+        },
+        paneTitles: {},
+      }
+
+      const store = createTestStore({
+        projects,
+        tabs: existingTabs,
+        panes,
+        activeTabId: null,
+        sortMode: 'activity',
+      })
       const { onNavigate } = renderSidebar(store, terminals)
 
       // Advance timers to process the mock response and wait for state update
@@ -1418,10 +1460,6 @@ describe('Sidebar Component - Session-Centric Display', () => {
         vi.advanceTimersByTime(100)
       })
 
-      // Verify the "Running" section appears (confirms terminals are loaded)
-      const runningSection = screen.queryByText('Running')
-      expect(runningSection).not.toBeNull()
-
       const sessionButton = screen.getByText('Running session').closest('button')
       fireEvent.click(sessionButton!)
 
@@ -1596,6 +1634,152 @@ describe('Sidebar Component - Session-Centric Display', () => {
   })
 
   describe('Search clear button', () => {
+    it('renders and clears a preloaded requested search from sidebar state', async () => {
+      const store = createTestStore({
+        sessions: {
+          activeSurface: 'sidebar',
+          windows: {
+            sidebar: {
+              projects: [],
+              lastLoadedAt: 1_700_000_000_000,
+              query: 'preloaded search',
+              searchTier: 'fullText',
+            },
+          },
+        },
+      })
+      const { getByPlaceholderText, getByRole, queryByRole } = renderSidebar(store, [])
+      await act(() => vi.advanceTimersByTime(100))
+
+      const input = getByPlaceholderText('Search...')
+      expect(input).toHaveValue('preloaded search')
+      expect(getByRole('combobox', { name: /search tier/i })).toHaveValue('fullText')
+
+      fireEvent.click(getByRole('button', { name: /clear search/i }))
+
+      expect(input).toHaveValue('')
+      expect(queryByRole('button', { name: /clear search/i })).not.toBeInTheDocument()
+      expect(queryByRole('combobox', { name: /search tier/i })).not.toBeInTheDocument()
+    })
+
+    it('does not write search request state to Redux until the debounced request starts', async () => {
+      const searchRequest = createDeferred<any>()
+      vi.mocked(mockSearchSessions).mockReturnValueOnce(searchRequest.promise)
+
+      const store = createTestStore({
+        sessions: {
+          activeSurface: 'sidebar',
+          windows: {
+            sidebar: {
+              projects: [],
+            },
+          },
+        },
+      })
+      const { getByPlaceholderText, getByRole } = renderSidebar(store, [])
+      await act(() => vi.advanceTimersByTime(100))
+
+      fireEvent.change(getByPlaceholderText('Search...'), { target: { value: 'draft query' } })
+      fireEvent.change(getByRole('combobox', { name: /search tier/i }), { target: { value: 'fullText' } })
+
+      expect((store.getState().sessions.windows.sidebar as any).query).toBeUndefined()
+      expect((store.getState().sessions.windows.sidebar as any).searchTier).toBeUndefined()
+
+      await act(() => vi.advanceTimersByTime(299))
+
+      expect((store.getState().sessions.windows.sidebar as any).query).toBeUndefined()
+      expect((store.getState().sessions.windows.sidebar as any).searchTier).toBeUndefined()
+
+      await act(async () => {
+        vi.advanceTimersByTime(1)
+        await Promise.resolve()
+      })
+
+      expect((store.getState().sessions.windows.sidebar as any).query).toBe('draft query')
+      expect((store.getState().sessions.windows.sidebar as any).searchTier).toBe('fullText')
+
+      await act(async () => {
+        searchRequest.resolve({
+          results: [],
+          tier: 'title',
+          query: 'draft query',
+          totalScanned: 0,
+        })
+        await Promise.resolve()
+      })
+    })
+
+    it('does not restart a newer debounced search when older results commit', async () => {
+      const alphaRequest = createDeferred<any>()
+      const betaRequest = createDeferred<any>()
+      vi.mocked(mockSearchSessions)
+        .mockReturnValueOnce(alphaRequest.promise)
+        .mockReturnValueOnce(betaRequest.promise)
+
+      const store = createTestStore({
+        sessions: {
+          activeSurface: 'sidebar',
+          windows: {
+            sidebar: {
+              projects: [],
+              lastLoadedAt: 1_700_000_000_000,
+            },
+          },
+        },
+      })
+      const { getByPlaceholderText } = renderSidebar(store, [])
+      await act(() => vi.advanceTimersByTime(100))
+
+      const input = getByPlaceholderText('Search...')
+      fireEvent.change(input, { target: { value: 'alpha' } })
+
+      await act(async () => {
+        vi.advanceTimersByTime(300)
+        await Promise.resolve()
+      })
+
+      expect(mockSearchSessions).toHaveBeenNthCalledWith(1, expect.objectContaining({
+        query: 'alpha',
+        tier: 'title',
+      }))
+
+      fireEvent.change(input, { target: { value: 'beta' } })
+
+      await act(() => vi.advanceTimersByTime(250))
+      expect(mockSearchSessions).toHaveBeenCalledTimes(1)
+
+      await act(async () => {
+        alphaRequest.resolve({
+          results: [],
+          tier: 'title',
+          query: 'alpha',
+          totalScanned: 0,
+        })
+        await Promise.resolve()
+      })
+
+      await act(async () => {
+        vi.advanceTimersByTime(50)
+        await Promise.resolve()
+      })
+
+      expect(mockSearchSessions).toHaveBeenCalledTimes(2)
+      expect(mockSearchSessions).toHaveBeenNthCalledWith(2, expect.objectContaining({
+        query: 'beta',
+        tier: 'title',
+      }))
+
+      await act(async () => {
+        betaRequest.resolve({
+          results: [],
+          tier: 'title',
+          query: 'beta',
+          totalScanned: 0,
+        })
+        await Promise.resolve()
+      })
+    })
+
     it('shows clear button when search has text', async () => {
       const store = createTestStore()
       const { getByPlaceholderText, getByRole, queryByRole } = renderSidebar(store, [])
@@ -1633,6 +1817,65 @@ describe('Sidebar Component - Session-Centric Display', () => {
   })
 
   describe('Search tier toggle', () => {
+    it('follows requested search updates from Redux after mount', async () => {
+      const store = createTestStore()
+      const { getByPlaceholderText, getByRole } = renderSidebar(store, [])
+      await act(() => vi.advanceTimersByTime(100))
+
+      act(() => {
+        store.dispatch(setSessionWindowLoading({
+          surface: 'sidebar',
+          loading: false,
+          query: 'store-driven query',
+          searchTier: 'userMessages',
+        }))
+      })
+
+      expect(getByPlaceholderText('Search...')).toHaveValue('store-driven query')
+      expect(getByRole('combobox', { name: /search tier/i })).toHaveValue('userMessages')
+      expect(getByRole('button', { name: /clear search/i })).toBeInTheDocument()
+    })
+
+    it('dispatches a preloaded requested search on mount when no applied result set is committed', async () => {
+      const searchRequest = createDeferred<any>()
+      vi.mocked(mockSearchSessions).mockReturnValueOnce(searchRequest.promise)
+
+      const store = createTestStore({
+        sessions: {
+          activeSurface: 'sidebar',
+          windows: {
+            sidebar: {
+              projects: [],
+              query: 'prefilled request',
+              searchTier: 'title',
+            },
+          },
+        },
+      })
+
+      renderSidebar(store, [])
+
+      await act(async () => {
+        vi.advanceTimersByTime(300)
+        await Promise.resolve()
+      })
+
+      expect(mockSearchSessions).toHaveBeenCalledWith(expect.objectContaining({
+        query: 'prefilled request',
+        tier: 'title',
+      }))
+
+      await act(async () => {
+        searchRequest.resolve({
+          results: [],
+          tier: 'title',
+          query: 'prefilled request',
+          totalScanned: 0,
+        })
+        await Promise.resolve()
+      })
+    })
+
     it('renders tier selector when searching', async () => {
       const store = createTestStore()
       const { getByPlaceholderText, getByRole } = renderSidebar(store, [])
@@ -1872,6 +2115,48 @@ describe('Sidebar Component - Session-Centric Display', () => {
       expect(searchInput).toHaveClass('pr-36')
     })
 
+    it('hides search chrome when clearing to browse while stale search results remain visible', async () => {
+      const searchProjects: ProjectGroup[] = [{
+        projectPath: '/work/search',
+        sessions: [{
+          provider: 'codex',
+          sessionId: 'search-session',
+          projectPath: '/work/search',
+          lastActivityAt: 1_700_000_000_000,
+          title: 'Search Result',
+        }],
+      }]
+
+      const store = createTestStore({
+        projects: searchProjects,
+        sessions: {
+          activeSurface: 'sidebar',
+          projects: searchProjects,
+          lastLoadedAt: 1_700_000_000_000,
+          windows: {
+            sidebar: {
+              projects: searchProjects,
+              lastLoadedAt: 1_700_000_000_000,
+              loading: true,
+              loadingKind: 'search',
+              query: '',
+              searchTier: 'title',
+              appliedQuery: 'search',
+              appliedSearchTier: 'title',
+            },
+          },
+        },
+      })
+
+      const { getByPlaceholderText } = renderSidebar(store, [])
+      const searchInput = getByPlaceholderText('Search...')
+
+      expect(searchInput).toHaveValue('')
+      expect(screen.getByText('Search Result')).toBeInTheDocument()
+      expect(screen.queryByTestId('search-loading')).not.toBeInTheDocument()
+      expect(screen.queryByRole('combobox', { name: /search tier/i })).not.toBeInTheDocument()
+    })
+
     it('keeps a loaded empty-state message visible during refresh', async () => {
       const store = createTestStore({
         projects: [],
@@ -2302,6 +2587,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               loading: false,
               query: 'search',
               searchTier: 'title',
+              appliedQuery: 'search',
+              appliedSearchTier: 'title',
             },
           },
         },
@@ -2314,7 +2601,33 @@ describe('Sidebar Component - Session-Centric Display', () => {
       expect(mockFetchSidebarSessionsSnapshot).not.toHaveBeenCalled()
     })
 
-    it('does not append while the user has typed an uncommitted sidebar search query', () => {
+    it('continues append pagination while the user has only typed an uncommitted sidebar search query', async () => {
+      vi.useRealTimers()
+
+      mockSearchSessions.mockResolvedValue({
+        results: [],
+        tier: 'title',
+        query: 'search',
+        totalScanned: 0,
+      } as any)
+
+      mockFetchSidebarSessionsSnapshot.mockResolvedValueOnce({
+        projects: [{
+          projectPath: '/older',
+          sessions: [{
+            provider: 'codex',
+            sessionId: 'older-session',
+            projectPath: '/older',
+            lastActivityAt: 10,
+            title: 'Older Session',
+          }],
+        }],
+        totalSessions: 2,
+        oldestIncludedTimestamp: 10,
+        oldestIncludedSessionId: 'codex:older-session',
+        hasMore: false,
+      })
+
       const store = createTestStore({
         sessions: {
           activeSurface: 'sidebar',
@@ -2348,7 +2661,18 @@ describe('Sidebar Component - Session-Centric Display', () => {
       const list = screen.getByTestId('sidebar-session-list')
       triggerNearBottomScroll(list, { clientHeight: 560, scrollHeight: 1120 })
 
-      expect(mockFetchSidebarSessionsSnapshot).not.toHaveBeenCalled()
+      await waitFor(() => {
+        expect(mockFetchSidebarSessionsSnapshot).toHaveBeenCalledWith(expect.objectContaining({
+          limit: 50,
+          before: 20,
+          beforeId: 'codex:recent-session',
+          signal: expect.any(AbortSignal),
+        }))
+      })
+      await waitFor(() => {
+        expect(screen.getByText('Older Session')).toBeInTheDocument()
+      })
+      expect(screen.getByText('Recent Session')).toBeInTheDocument()
     })
 
     it('releases the sidebar append guard even when another session surface is active', async () => {
@@ -2612,8 +2936,27 @@ describe('Sidebar Component - Session-Centric Display', () => {
         },
       ]
 
-      const store = createTestStore({ projects, tabs, activeTabId: 'tab-1', sessionOpenMode: 'split' })
-      const { onNavigate } = renderSidebar(store, [])
+      const panes = {
+        layouts: {
+          'tab-1': {
+            type: 'leaf',
+            id: 'pane-1',
+            content: {
+              kind: 'terminal',
+              mode: 'shell',
+              createRequestId: 'req-1',
+              status: 'running',
+            },
+          },
+        },
+        activePane: {
+          'tab-1': 'pane-1',
+        },
+        paneTitles: {},
+      }
+
+      const store = createTestStore({ projects, tabs, panes, activeTabId: 'tab-1', sessionOpenMode: 'split' })
+      const { onNavigate } = renderSidebar(store, [])
 
       await act(async () => {
         vi.advanceTimersByTime(100)
@@ -2864,6 +3207,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               lastLoadedAt: Date.now(),
               query: 'test',
               searchTier: 'fullText',
+              appliedQuery: 'test',
+              appliedSearchTier: 'fullText',
               deepSearchPending: true,
               loading: false,
             },
@@ -2873,10 +3218,6 @@ describe('Sidebar Component - Session-Centric Display', () => {
 
       renderSidebar(store, [])
 
-      // Need to type in the search box so the filter.trim() conditional shows the tier dropdown
-      fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'test' } })
-      await act(() => vi.advanceTimersByTime(0))
-
       expect(screen.getByText('Scanning files...')).toBeInTheDocument()
       expect(screen.getByText('Scanning files...').closest('[role="status"]')).toBeInTheDocument()
     })
@@ -2898,6 +3239,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               lastLoadedAt: Date.now(),
               query: 'test',
               searchTier: 'fullText',
+              appliedQuery: 'test',
+              appliedSearchTier: 'fullText',
               deepSearchPending: false,
               loading: false,
             },
@@ -2907,9 +3250,6 @@ describe('Sidebar Component - Session-Centric Display', () => {
 
       renderSidebar(store, [])
 
-      fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'test' } })
-      await act(() => vi.advanceTimersByTime(0))
-
       expect(screen.queryByText('Scanning files...')).not.toBeInTheDocument()
     })
 
@@ -2925,6 +3265,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               lastLoadedAt: Date.now(),
               query: 'test',
               searchTier: 'fullText',
+              appliedQuery: 'test',
+              appliedSearchTier: 'fullText',
               deepSearchPending: true,
               loading: false,
             },
@@ -2934,9 +3276,6 @@ describe('Sidebar Component - Session-Centric Display', () => {
 
       renderSidebar(store, [])
 
-      fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'test' } })
-      await act(() => vi.advanceTimersByTime(0))
-
       expect(screen.getByText('Scanning files...')).toBeInTheDocument()
       expect(screen.queryByText('No results found')).not.toBeInTheDocument()
     })
@@ -2958,6 +3297,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               lastLoadedAt: Date.now(),
               query: 'test',
               searchTier: 'fullText',
+              appliedQuery: 'test',
+              appliedSearchTier: 'fullText',
               deepSearchPending: true,
               loading: false,
             },
@@ -2966,9 +3307,6 @@ describe('Sidebar Component - Session-Centric Display', () => {
       })
 
       renderSidebar(store, [])
-
-      fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'test' } })
-      await act(() => vi.advanceTimersByTime(0))
       expect(screen.getByText('Scanning files...')).toBeInTheDocument()
 
       // Clear the search
@@ -2995,6 +3333,8 @@ describe('Sidebar Component - Session-Centric Display', () => {
               lastLoadedAt: Date.now(),
               query: 'test',
               searchTier: 'fullText',
+              appliedQuery: 'test',
+              appliedSearchTier: 'fullText',
               deepSearchPending: true,
               loading: false,
             },
@@ -3004,13 +3344,456 @@ describe('Sidebar Component - Session-Centric Display', () => {
 
       renderSidebar(store, [])
 
-      fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'test' } })
-      await act(() => vi.advanceTimersByTime(0))
-
       const statusElement = screen.getByRole('status')
       expect(statusElement).toBeInTheDocument()
       expect(statusElement.getAttribute('aria-live')).toBe('polite')
       expect(statusElement.textContent).toContain('Scanning files...')
     })
   })
+
+  describe('applied search fallback behavior', () => {
+    it('shows only matching title-search fallback tabs and keeps them unpinned below newer server results', async () => {
+      const matchingFallbackSessionId = sessionId('matching-fallback')
+      const unrelatedFallbackSessionId = sessionId('unrelated-fallback')
+      const searchProjects: ProjectGroup[] = [
+        {
+          projectPath: '/work/server',
+          sessions: [
+            {
+              provider: 'codex',
+              sessionId: 'server-newer',
+              projectPath: '/work/server',
+              lastActivityAt: 3_000,
+              title: 'Newer Server Result',
+            },
+          ],
+        },
+        {
+          projectPath: '/work/repos/trycycle',
+          sessions: [
+            {
+              provider: 'codex',
+              sessionId: 'server-leaf',
+              projectPath: '/work/repos/trycycle',
+              cwd: '/work/repos/trycycle/server',
+              lastActivityAt: 2_500,
+              title: 'Routine work',
+            },
+          ],
+        },
+      ]
+
+      const store = createTestStore({
+        projects: searchProjects,
+        tabs: [
+          {
+            id: 'tab-match',
+            title: 'Matching Fallback',
+            mode: 'codex',
+            resumeSessionId: matchingFallbackSessionId,
+            createdAt: 1_000,
+          },
+          {
+            id: 'tab-unrelated',
+            title: 'Unrelated Fallback',
+            mode: 'codex',
+            resumeSessionId: unrelatedFallbackSessionId,
+            createdAt: 900,
+          },
+        ],
+        panes: {
+          layouts: {
+            'tab-match': {
+              type: 'leaf',
+              id: 'pane-match',
+              content: {
+                kind: 'terminal',
+                mode: 'codex',
+                createRequestId: 'req-match',
+                status: 'running',
+                resumeSessionId: matchingFallbackSessionId,
+                initialCwd: '/tmp/local/trycycle',
+              },
+            },
+            'tab-unrelated': {
+              type: 'leaf',
+              id: 'pane-unrelated',
+              content: {
+                kind: 'terminal',
+                mode: 'codex',
+                createRequestId: 'req-unrelated',
+                status: 'running',
+                resumeSessionId: unrelatedFallbackSessionId,
+                initialCwd: '/tmp/local/elsewhere',
+              },
+            },
+          },
+          activePane: {
+            'tab-match': 'pane-match',
+            'tab-unrelated': 'pane-unrelated',
+          },
+          paneTitles: {
+            'tab-match': {
+              'pane-match': 'Matching Fallback',
+            },
+            'tab-unrelated': {
+              'pane-unrelated': 'Unrelated Fallback',
+            },
+          },
+        },
+        sessions: {
+          activeSurface: 'sidebar',
+          projects: searchProjects,
+          lastLoadedAt: 1_700_000_000_000,
+          windows: {
+            sidebar: {
+              projects: searchProjects,
+              lastLoadedAt: 1_700_000_000_000,
+              query: 'trycycle',
+              searchTier: 'title',
+              appliedQuery: 'trycycle',
+              appliedSearchTier: 'title',
+              loading: false,
+            },
+          },
+        },
+        sortMode: 'activity',
+      })
+
+      renderSidebar(store, [])
+
+      expect(screen.getByText('Newer Server Result')).toBeInTheDocument()
+      expect(screen.getByText('Routine work')).toBeInTheDocument()
+      expect(screen.getByText('Matching Fallback')).toBeInTheDocument()
+      expect(screen.queryByText('Unrelated Fallback')).not.toBeInTheDocument()
+      expect(getSidebarSessionOrder([
+        'Newer Server Result',
+        'Routine work',
+        'Matching Fallback',
+      ])).toEqual([
+        'Newer Server Result',
+        'Routine work',
+        'Matching Fallback',
+      ])
+    })
+
+    it('hides fallback tabs entirely while a deep-search result set is on screen', async () => {
+      const deepFallbackSessionId = sessionId('deep-fallback')
+      const deepProjects: ProjectGroup[] = [
+        {
+          projectPath: '/work/deep',
+          sessions: [
+            {
+              provider: 'claude',
+              sessionId: 'deep-server',
+              projectPath: '/work/deep',
+              lastActivityAt: 3_000,
+              title: 'Deep Search Result',
+            },
+          ],
+        },
+      ]
+
+      const store = createTestStore({
+        projects: deepProjects,
+        tabs: [{
+          id: 'tab-deep',
+          title: 'Deep Matching Fallback',
+          mode: 'codex',
+          resumeSessionId: deepFallbackSessionId,
+          createdAt: 1_000,
+        }],
+        panes: {
+          layouts: {
+            'tab-deep': {
+              type: 'leaf',
+              id: 'pane-deep',
+              content: {
+                kind: 'terminal',
+                mode: 'codex',
+                createRequestId: 'req-deep',
+                status: 'running',
+                resumeSessionId: deepFallbackSessionId,
+                initialCwd: '/tmp/local/trycycle',
+              },
+            },
+          },
+          activePane: {
+            'tab-deep': 'pane-deep',
+          },
+          paneTitles: {
+            'tab-deep': {
+              'pane-deep': 'Deep Matching Fallback',
+            },
+          },
+        },
+        sessions: {
+          activeSurface: 'sidebar',
+          projects: deepProjects,
+          lastLoadedAt: 1_700_000_000_000,
+          windows: {
+            sidebar: {
+              projects: deepProjects,
+              lastLoadedAt: 1_700_000_000_000,
+              query: 'trycycle',
+              searchTier: 'fullText',
+              appliedQuery: 'trycycle',
+              appliedSearchTier: 'fullText',
+              loading: false,
+            },
+          },
+        },
+      })
+
+      renderSidebar(store, [])
+
+      expect(screen.getByText('Deep Search Result')).toBeInTheDocument()
+      expect(screen.queryByText('Deep Matching Fallback')).not.toBeInTheDocument()
+    })
+
+    it('keeps the previous applied title-search result set visible while a replacement search is loading', async () => {
+      const replacementSearch = createDeferred<any>()
+      const alphaFallbackSessionId = sessionId('alpha-fallback')
+      const betaFallbackSessionId = sessionId('beta-fallback')
+      vi.mocked(mockSearchSessions).mockReturnValueOnce(replacementSearch.promise)
+
+      const alphaProjects: ProjectGroup[] = [
+        {
+          projectPath: '/work/alpha',
+          sessions: [
+            {
+              provider: 'codex',
+              sessionId: 'alpha-server',
+              projectPath: '/work/alpha',
+              lastActivityAt: 3_000,
+              title: 'Alpha Server Result',
+            },
+          ],
+        },
+      ]
+
+      const store = createTestStore({
+        projects: alphaProjects,
+        tabs: [
+          {
+            id: 'tab-alpha-fallback',
+            title: 'Alpha Fallback',
+            mode: 'codex',
+            resumeSessionId: alphaFallbackSessionId,
+            createdAt: 1_000,
+          },
+          {
+            id: 'tab-beta-fallback',
+            title: 'Beta Fallback',
+            mode: 'codex',
+            resumeSessionId: betaFallbackSessionId,
+            createdAt: 900,
+          },
+        ],
+        panes: {
+          layouts: {
+            'tab-alpha-fallback': {
+              type: 'leaf',
+              id: 'pane-alpha-fallback',
+              content: {
+                kind: 'terminal',
+                mode: 'codex',
+                createRequestId: 'req-alpha-fallback',
+                status: 'running',
+                resumeSessionId: alphaFallbackSessionId,
+                initialCwd: '/tmp/local/alpha',
+              },
+            },
+            'tab-beta-fallback': {
+              type: 'leaf',
+              id: 'pane-beta-fallback',
+              content: {
+                kind: 'terminal',
+                mode: 'codex',
+                createRequestId: 'req-beta-fallback',
+                status: 'running',
+                resumeSessionId: betaFallbackSessionId,
+                initialCwd: '/tmp/local/beta',
+              },
+            },
+          },
+          activePane: {
+            'tab-alpha-fallback': 'pane-alpha-fallback',
+            'tab-beta-fallback': 'pane-beta-fallback',
+          },
+          paneTitles: {
+            'tab-alpha-fallback': {
+              'pane-alpha-fallback': 'Alpha Fallback',
+            },
+            'tab-beta-fallback': {
+              'pane-beta-fallback': 'Beta Fallback',
+            },
+          },
+        },
+        sessions: {
+          activeSurface: 'sidebar',
+          projects: alphaProjects,
+          lastLoadedAt: 1_700_000_000_000,
+          windows: {
+            sidebar: {
+              projects: alphaProjects,
+              lastLoadedAt: 1_700_000_000_000,
+              query: 'alpha',
+              searchTier: 'title',
+              appliedQuery: 'alpha',
+              appliedSearchTier: 'title',
+              loading: false,
+            },
+          },
+        },
+      })
+
+      renderSidebar(store, [])
+
+      try {
+        fireEvent.change(screen.getByPlaceholderText('Search...'), { target: { value: 'beta' } })
+
+        await act(async () => {
+          vi.advanceTimersByTime(350)
+          await Promise.resolve()
+        })
+
+        expect(screen.getByTestId('search-loading')).toBeInTheDocument()
+        expect(screen.getByText('Alpha Server Result')).toBeInTheDocument()
+        expect(screen.getByText('Alpha Fallback')).toBeInTheDocument()
+        expect(screen.queryByText('Beta Fallback')).not.toBeInTheDocument()
+      } finally {
+        replacementSearch.resolve({
+          results: [],
+          tier: 'title',
+          query: 'beta',
+          totalScanned: 0,
+        })
+
+        await act(async () => {
+          await Promise.resolve()
+          await Promise.resolve()
+        })
+      }
+    })
+
+    it('keeps browse append disabled until browse data replaces stale applied search results', async () => {
+      vi.useRealTimers()
+
+      const browseProjects: ProjectGroup[] = [{
+        projectPath: '/browse',
+        sessions: [{
+          provider: 'codex',
+          sessionId: 'browse-session',
+          projectPath: '/browse',
+          lastActivityAt: 20,
+          title: 'Browse Session',
+        }],
+      }]
+
+      mockFetchSidebarSessionsSnapshot.mockResolvedValueOnce({
+        projects: [{
+          projectPath: '/older',
+          sessions: [{
+            provider: 'codex',
+            sessionId: 'older-session',
+            projectPath: '/older',
+            lastActivityAt: 10,
+            title: 'Older Session',
+          }],
+        }],
+        totalSessions: 2,
+        oldestIncludedTimestamp: 10,
+        oldestIncludedSessionId: 'codex:older-session',
+        hasMore: false,
+      })
+
+      const store = createTestStore({
+        projects: [{
+          projectPath: '/search',
+          sessions: [{
+            provider: 'codex',
+            sessionId: 'search-session',
+            projectPath: '/search',
+            lastActivityAt: 30,
+            title: 'Search Result',
+          }],
+        }],
+        sessions: {
+          activeSurface: 'sidebar',
+          projects: [{
+            projectPath: '/search',
+            sessions: [{
+              provider: 'codex',
+              sessionId: 'search-session',
+              projectPath: '/search',
+              lastActivityAt: 30,
+              title: 'Search Result',
+            }],
+          }],
+          lastLoadedAt: 1_700_000_000_000,
+          hasMore: true,
+          oldestLoadedTimestamp: 30,
+          oldestLoadedSessionId: 'codex:search-session',
+          windows: {
+            sidebar: {
+              projects: [{
+                projectPath: '/search',
+                sessions: [{
+                  provider: 'codex',
+                  sessionId: 'search-session',
+                  projectPath: '/search',
+                  lastActivityAt: 30,
+                  title: 'Search Result',
+                }],
+              }],
+              lastLoadedAt: 1_700_000_000_000,
+              hasMore: true,
+              oldestLoadedTimestamp: 30,
+              oldestLoadedSessionId: 'codex:search-session',
+              loading: true,
+              loadingKind: 'search',
+              query: '',
+              searchTier: 'title',
+              appliedQuery: 'search',
+              appliedSearchTier: 'title',
+            },
+          },
+        },
+      })
+
+      renderSidebar(store)
+      const list = screen.getByTestId('sidebar-session-list')
+
+      triggerNearBottomScroll(list, { clientHeight: 560, scrollHeight: 1120 })
+      expect(mockFetchSidebarSessionsSnapshot).not.toHaveBeenCalled()
+
+      await act(async () => {
+        store.dispatch(commitSessionWindowReplacement({
+          surface: 'sidebar',
+          projects: browseProjects,
+          totalSessions: 1,
+          hasMore: true,
+          oldestLoadedTimestamp: 20,
+          oldestLoadedSessionId: 'codex:browse-session',
+          query: '',
+          searchTier: 'title',
+        }))
+      })
+
+      triggerNearBottomScroll(list, { clientHeight: 560, scrollHeight: 1120 })
+
+      await waitFor(() => {
+        expect(mockFetchSidebarSessionsSnapshot).toHaveBeenCalledWith(expect.objectContaining({
+          limit: 50,
+          before: 20,
+          beforeId: 'codex:browse-session',
+          signal: expect.any(AbortSignal),
+        }))
+      })
+      await waitFor(() => {
+        expect(screen.getByText('Older Session')).toBeInTheDocument()
+      })
+    })
+  })
 })
diff --git a/test/unit/client/components/TerminalView.keyboard.test.tsx b/test/unit/client/components/TerminalView.keyboard.test.tsx
index 07dbaa61..4cdc49cc 100644
--- a/test/unit/client/components/TerminalView.keyboard.test.tsx
+++ b/test/unit/client/components/TerminalView.keyboard.test.tsx
@@ -37,7 +37,10 @@ vi.mock('lucide-react', () => ({
 let capturedKeyHandler: ((event: KeyboardEvent) => boolean) | null = null
 let capturedOnData: ((data: string) => void) | null = null
 let capturedTerminal: { paste: ReturnType<typeof vi.fn> } | null = null
-let capturedLinkProvider: {
+let capturedLinkProviders: Array<{
+  provideLinks: (line: number, callback: (links: any[] | undefined) => void) => void
+}> = []
+let capturedFilePathProvider: {
   provideLinks: (line: number, callback: (links: any[] | undefined) => void) => void
 } | null = null
 
@@ -56,7 +59,7 @@ vi.mock('@xterm/xterm', () => {
     open = vi.fn()
     loadAddon = vi.fn()
     registerLinkProvider = vi.fn((provider: any) => {
-      capturedLinkProvider = provider
+      capturedLinkProviders.push(provider)
       return { dispose: vi.fn() }
     })
     write = vi.fn()
@@ -308,7 +311,8 @@ describe('TerminalView keyboard handling', () => {
     capturedKeyHandler = null
     capturedOnData = null
     capturedTerminal = null
-    capturedLinkProvider = null
+    capturedLinkProviders = []
+    capturedFilePathProvider = null
     wsMocks.send.mockClear()
     clipboardMocks.readText.mockClear()
     clipboardMocks.copyText.mockClear()
@@ -860,11 +864,12 @@ describe('TerminalView keyboard handling', () => {
       )
 
       await waitFor(() => {
-        expect(capturedLinkProvider).not.toBeNull()
+        capturedFilePathProvider = capturedLinkProviders[0] ?? null
+        expect(capturedFilePathProvider).not.toBeNull()
       })
 
       let links: any[] | undefined
-      capturedLinkProvider!.provideLinks(1, (provided) => {
+      capturedFilePathProvider!.provideLinks(1, (provided) => {
         links = provided
       })
 
@@ -874,27 +879,31 @@ describe('TerminalView keyboard handling', () => {
 
       links![0].activate()
 
-      const state = store.getState()
-      expect(state.tabs.tabs).toHaveLength(1)
-      expect(state.tabs.activeTabId).toBe(tabId)
-
-      const layout = state.panes.layouts[tabId]
-      expect(layout.type).toBe('split')
-      if (layout.type !== 'split') {
-        throw new Error('expected split layout')
-      }
+      expect(store.getState().panes.layouts[tabId].type).toBe('leaf')
 
-      expect(layout.children[0]).toMatchObject({ type: 'leaf', id: paneId })
-      expect(layout.children[1]).toMatchObject({
-        type: 'leaf',
-        content: {
-          kind: 'editor',
-          filePath: '/tmp/example.txt',
-          language: null,
-          readOnly: false,
-          content: '',
-          viewMode: 'source',
-        },
+      await waitFor(() => {
+        const state = store.getState()
+        expect(state.tabs.tabs).toHaveLength(1)
+        expect(state.tabs.activeTabId).toBe(tabId)
+
+        const layout = state.panes.layouts[tabId]
+        expect(layout.type).toBe('split')
+        if (layout.type !== 'split') {
+          throw new Error('expected split layout')
+        }
+
+        expect(layout.children[0]).toMatchObject({ type: 'leaf', id: paneId })
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: {
+            kind: 'editor',
+            filePath: '/tmp/example.txt',
+            language: null,
+            readOnly: false,
+            content: '',
+            viewMode: 'source',
+          },
+        })
       })
     })
 
@@ -930,38 +939,74 @@ describe('TerminalView keyboard handling', () => {
       )
 
       await waitFor(() => {
-        expect(capturedLinkProvider).not.toBeNull()
+        capturedFilePathProvider = capturedLinkProviders[0] ?? null
+        expect(capturedFilePathProvider).not.toBeNull()
       })
 
       let links: any[] | undefined
-      capturedLinkProvider!.provideLinks(1, (provided) => {
+      capturedFilePathProvider!.provideLinks(1, (provided) => {
         links = provided
       })
 
       links![0].activate()
 
-      const root = store.getState().panes.layouts[tabId]
-      expect(root.type).toBe('split')
-      if (root.type !== 'split') {
-        throw new Error('expected root split layout')
-      }
+      expect(store.getState().panes.layouts[tabId]).toEqual(layout)
 
-      expect(root.children[0]).toMatchObject({ type: 'leaf', id: activePaneId })
+      await waitFor(() => {
+        const root = store.getState().panes.layouts[tabId]
+        expect(root.type).toBe('split')
+        if (root.type !== 'split') {
+          throw new Error('expected root split layout')
+        }
+
+        expect(root.children[0]).toMatchObject({ type: 'leaf', id: activePaneId })
+
+        const clickedBranch = root.children[1]
+        expect(clickedBranch.type).toBe('split')
+        if (clickedBranch.type !== 'split') {
+          throw new Error('expected clicked branch split layout')
+        }
+
+        expect(clickedBranch.children[0]).toMatchObject({ type: 'leaf', id: clickedPaneId })
+        expect(clickedBranch.children[1]).toMatchObject({
+          type: 'leaf',
+          content: {
+            kind: 'editor',
+            filePath: '/tmp/example.txt',
+          },
+        })
+      })
+    })
 
-      const clickedBranch = root.children[1]
-      expect(clickedBranch.type).toBe('split')
-      if (clickedBranch.type !== 'split') {
-        throw new Error('expected clicked branch split layout')
-      }
+    it('does not activate file path link on right-click', async () => {
+      const { store, tabId, paneId, paneContent } = createTestStore('term-1')
 
-      expect(clickedBranch.children[0]).toMatchObject({ type: 'leaf', id: clickedPaneId })
-      expect(clickedBranch.children[1]).toMatchObject({
-        type: 'leaf',
-        content: {
-          kind: 'editor',
-          filePath: '/tmp/example.txt',
-        },
+      render(
+        <Provider store={store}>
+          <TerminalView tabId={tabId} paneId={paneId} paneContent={paneContent} />
+        </Provider>
+      )
+
+      await waitFor(() => {
+        capturedFilePathProvider = capturedLinkProviders[0] ?? null
+        expect(capturedFilePathProvider).not.toBeNull()
+      })
+
+      let links: any[] | undefined
+      capturedFilePathProvider!.provideLinks(1, (provided) => {
+        links = provided
       })
+
+      expect(links).toBeDefined()
+      expect(links).toHaveLength(1)
+
+      const layoutBefore = store.getState().panes.layouts[tabId]
+      expect(layoutBefore.type).toBe('leaf')
+
+      links![0].activate(new MouseEvent('click', { button: 2 }))
+
+      const layoutAfter = store.getState().panes.layouts[tabId]
+      expect(layoutAfter.type).toBe('leaf')
     })
   })
 })
diff --git a/test/unit/client/components/TerminalView.lifecycle.test.tsx b/test/unit/client/components/TerminalView.lifecycle.test.tsx
index 62149b00..359998c5 100644
--- a/test/unit/client/components/TerminalView.lifecycle.test.tsx
+++ b/test/unit/client/components/TerminalView.lifecycle.test.tsx
@@ -2030,7 +2030,7 @@ describe('TerminalView lifecycle updates', () => {
     expect(layout.content.status).toBe('creating')
 
     await act(async () => {
-      vi.advanceTimersByTime(250)
+      vi.advanceTimersByTime(2000)
     })
 
     const createCallsAfter = wsMocks.send.mock.calls.filter(([msg]) => msg?.type === 'terminal.create')
@@ -2381,6 +2381,85 @@ describe('TerminalView lifecycle updates', () => {
       expect(queryByText('Recovering terminal output...')).not.toBeNull()
     })
 
+    it('does not show recovering banner on fresh terminal creation', async () => {
+      const tabId = 'tab-fresh'
+      const paneId = 'pane-fresh'
+      const paneContent: TerminalPaneContent = {
+        kind: 'terminal',
+        createRequestId: 'req-fresh',
+        status: 'creating',
+        mode: 'shell',
+        shell: 'system',
+      }
+
+      const root: PaneNode = { type: 'leaf', id: paneId, content: paneContent }
+      const store = configureStore({
+        reducer: {
+          tabs: tabsReducer,
+          panes: panesReducer,
+          settings: settingsReducer,
+          connection: connectionReducer,
+          turnCompletion: turnCompletionReducer,
+        },
+        preloadedState: {
+          tabs: {
+            tabs: [{
+              id: tabId,
+              mode: 'shell',
+              status: 'creating',
+              title: 'Shell',
+              titleSetByUser: false,
+              createRequestId: 'req-fresh',
+            }],
+            activeTabId: tabId,
+          },
+          panes: {
+            layouts: { [tabId]: root },
+            activePane: { [tabId]: paneId },
+            paneTitles: {},
+          },
+          settings: createSettingsState(),
+          connection: {
+            status: 'ready',
+            error: null,
+          },
+          turnCompletion: { seq: 0, lastEvent: null, pendingEvents: [], attentionByTab: {} },
+        },
+      })
+
+      // Use TerminalViewFromStore so paneContent updates from Redux reach the component
+      const { queryByText } = render(
+        <Provider store={store}>
+          <TerminalViewFromStore tabId={tabId} paneId={paneId} />
+        </Provider>
+      )
+
+      // Wait for create request to be sent
+      await waitFor(() => {
+        expect(wsMocks.send).toHaveBeenCalledWith(expect.objectContaining({
+          type: 'terminal.create',
+          requestId: 'req-fresh',
+        }))
+      })
+
+      // Simulate server responding with terminal.created
+      // This triggers: updateContent({ status: 'running' }) then attachTerminal(viewport_hydrate)
+      act(() => {
+        messageHandler!({ type: 'terminal.created', requestId: 'req-fresh', terminalId: 'term-fresh-1', createdAt: Date.now() })
+      })
+
+      // After terminal.created, status is 'running' and isAttaching is true
+      // but the banner should NOT show because this is a fresh terminal
+      await waitFor(() => {
+        expect(wsMocks.send).toHaveBeenCalledWith(expect.objectContaining({
+          type: 'terminal.attach',
+          terminalId: 'term-fresh-1',
+        }))
+      })
+
+      expect(queryByText('Recovering terminal output...')).toBeNull()
+    })
+
     it('shows inline offline status while disconnected without blocking overlay', async () => {
       const { tabId, paneId, paneContent, store } = setupNonBlockingTerminal('disconnected')
 
diff --git a/test/unit/client/components/TerminalView.linkWarning.test.tsx b/test/unit/client/components/TerminalView.linkWarning.test.tsx
index 7b249a20..ab28950f 100644
--- a/test/unit/client/components/TerminalView.linkWarning.test.tsx
+++ b/test/unit/client/components/TerminalView.linkWarning.test.tsx
@@ -132,11 +132,11 @@ function createStore(settingsOverride?: Partial<AppSettings>) {
   })
 }
 
-function activateLinkHandler(uri: string) {
+function activateLinkHandler(uri: string, button = 0) {
   const term = terminalInstances[terminalInstances.length - 1]
   const handler = term.options.linkHandler as { activate: (event: MouseEvent, uri: string) => void }
   act(() => {
-    handler.activate(new MouseEvent('click'), uri)
+    handler.activate(new MouseEvent('click', { button }), uri)
   })
 }
 
@@ -199,8 +199,16 @@ describe('TerminalView link warning', () => {
     fireEvent.click(screen.getByText('Open link'))
 
     await waitFor(() => {
-      expect(windowOpenSpy).toHaveBeenCalledWith('https://example.com/page', '_blank', 'noopener,noreferrer')
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+      if (layout.type === 'split') {
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: { kind: 'browser', url: 'https://example.com/page', devToolsOpen: false },
+        })
+      }
     })
+    expect(windowOpenSpy).not.toHaveBeenCalled()
     expect(screen.queryByText('Open external link?')).not.toBeInTheDocument()
   })
 
@@ -246,9 +254,56 @@ describe('TerminalView link warning', () => {
 
     activateLinkHandler('https://trusted.example.com')
 
+    expect(store.getState().panes.layouts['tab-1'].type).toBe('leaf')
+
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+      if (layout.type === 'split') {
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: { kind: 'browser', url: 'https://trusted.example.com', devToolsOpen: false },
+        })
+      }
+    })
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+    expect(screen.queryByText('Open external link?')).not.toBeInTheDocument()
+  })
+
+  it('does not activate link on right-click', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
     await waitFor(() => {
-      expect(windowOpenSpy).toHaveBeenCalledWith('https://trusted.example.com', '_blank', 'noopener,noreferrer')
+      expect(terminalInstances).toHaveLength(1)
     })
+
+    activateLinkHandler('https://example.com', 2)
+
     expect(screen.queryByText('Open external link?')).not.toBeInTheDocument()
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+  })
+
+  it('does not activate link on middle-click', async () => {
+    const store = createStore({ terminal: { ...defaultSettings.terminal, warnExternalLinks: false } })
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    activateLinkHandler('https://example.com', 1)
+
+    expect(windowOpenSpy).not.toHaveBeenCalled()
   })
 })
diff --git a/test/unit/client/components/TerminalView.rateLimit.test.ts b/test/unit/client/components/TerminalView.rateLimit.test.ts
new file mode 100644
index 00000000..0e7645c5
--- /dev/null
+++ b/test/unit/client/components/TerminalView.rateLimit.test.ts
@@ -0,0 +1,35 @@
+// Verify that rate-limit retry backoff outlasts the server's rate window
+import { describe, it, expect } from 'vitest'
+import {
+  RATE_LIMIT_RETRY_MAX_ATTEMPTS,
+  RATE_LIMIT_RETRY_BASE_MS,
+  RATE_LIMIT_RETRY_MAX_MS,
+} from '@/components/TerminalView'
+
+const SERVER_RATE_WINDOW_MS = 10_000
+
+describe('rate-limit retry backoff', () => {
+  it('total retry span exceeds the server rate-limit window', () => {
+    let totalDelayMs = 0
+    for (let i = 1; i <= RATE_LIMIT_RETRY_MAX_ATTEMPTS; i++) {
+      totalDelayMs += Math.min(
+        RATE_LIMIT_RETRY_BASE_MS * (2 ** (i - 1)),
+        RATE_LIMIT_RETRY_MAX_MS
+      )
+    }
+    expect(totalDelayMs).toBeGreaterThan(SERVER_RATE_WINDOW_MS)
+  })
+
+  it('at least one retry fires after the rate-limit window expires', () => {
+    let cumulativeMs = 0
+    let retriesAfterWindow = 0
+    for (let i = 1; i <= RATE_LIMIT_RETRY_MAX_ATTEMPTS; i++) {
+      cumulativeMs += Math.min(
+        RATE_LIMIT_RETRY_BASE_MS * (2 ** (i - 1)),
+        RATE_LIMIT_RETRY_MAX_MS
+      )
+      if (cumulativeMs > SERVER_RATE_WINDOW_MS) retriesAfterWindow++
+    }
+    expect(retriesAfterWindow).toBeGreaterThanOrEqual(1)
+  })
+})
diff --git a/test/unit/client/components/TerminalView.urlClick.test.tsx b/test/unit/client/components/TerminalView.urlClick.test.tsx
new file mode 100644
index 00000000..0a13eaa5
--- /dev/null
+++ b/test/unit/client/components/TerminalView.urlClick.test.tsx
@@ -0,0 +1,630 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { render, screen, fireEvent, cleanup, waitFor, act } from '@testing-library/react'
+import { Provider } from 'react-redux'
+import { configureStore } from '@reduxjs/toolkit'
+import TerminalView from '@/components/TerminalView'
+import tabsReducer from '@/store/tabsSlice'
+import panesReducer from '@/store/panesSlice'
+import settingsReducer, { defaultSettings } from '@/store/settingsSlice'
+import connectionReducer from '@/store/connectionSlice'
+import turnCompletionReducer from '@/store/turnCompletionSlice'
+import { getHoveredUrl, clearHoveredUrl } from '@/lib/terminal-hovered-url'
+import type { TerminalPaneContent } from '@/store/paneTypes'
+import type { AppSettings } from '@/store/types'
+
+const wsMocks = vi.hoisted(() => ({
+  send: vi.fn(),
+  connect: vi.fn().mockResolvedValue(undefined),
+  onMessage: vi.fn(() => () => {}),
+  onReconnect: vi.fn(() => () => {}),
+}))
+
+vi.mock('@/lib/ws-client', () => ({
+  getWsClient: () => wsMocks,
+}))
+
+vi.mock('@/hooks/useNotificationSound', () => ({
+  useNotificationSound: () => ({ play: vi.fn() }),
+}))
+
+vi.mock('@/lib/terminal-themes', () => ({
+  getTerminalTheme: () => ({}),
+}))
+
+const terminalInstances: any[] = []
+const registeredLinkProviders: any[] = []
+
+vi.mock('@xterm/xterm', () => {
+  class MockTerminal {
+    options: Record<string, unknown> = {}
+    cols = 80
+    rows = 24
+    paneId: string | null = null
+    buffer = {
+      active: {
+        getLine: vi.fn(() => ({
+          translateToString: () => 'Visit https://detected.example.com here',
+        })),
+      },
+    }
+    open = vi.fn((element: HTMLElement) => {
+      this.paneId = element.closest('[data-pane-id]')?.getAttribute('data-pane-id') ?? null
+    })
+    loadAddon = vi.fn()
+    registerLinkProvider = vi.fn((provider: any) => {
+      registeredLinkProviders.push(provider)
+      return { dispose: vi.fn() }
+    })
+    write = vi.fn()
+    writeln = vi.fn()
+    clear = vi.fn()
+    dispose = vi.fn()
+    onData = vi.fn()
+    onTitleChange = vi.fn(() => ({ dispose: vi.fn() }))
+    attachCustomKeyEventHandler = vi.fn()
+    getSelection = vi.fn(() => '')
+    focus = vi.fn()
+    selectAll = vi.fn()
+    reset = vi.fn()
+    scrollToBottom = vi.fn()
+    constructor(opts?: Record<string, unknown>) {
+      if (opts) this.options = opts
+      terminalInstances.push(this)
+    }
+  }
+
+  return { Terminal: MockTerminal }
+})
+
+vi.mock('@xterm/addon-fit', () => ({
+  FitAddon: class {
+    fit = vi.fn()
+  },
+}))
+
+vi.mock('@xterm/xterm/css/xterm.css', () => ({}))
+
+class MockResizeObserver {
+  observe = vi.fn()
+  disconnect = vi.fn()
+  unobserve = vi.fn()
+}
+
+const paneContent: TerminalPaneContent = {
+  kind: 'terminal',
+  createRequestId: 'req-1',
+  status: 'running',
+  mode: 'shell',
+  shell: 'system',
+  terminalId: 'term-1',
+  initialCwd: '/tmp',
+}
+
+function createStore(settingsOverride?: Partial<AppSettings>) {
+  const mergedSettings = {
+    ...defaultSettings,
+    ...settingsOverride,
+    terminal: { ...defaultSettings.terminal, ...settingsOverride?.terminal },
+  }
+
+  return configureStore({
+    reducer: {
+      tabs: tabsReducer,
+      panes: panesReducer,
+      settings: settingsReducer,
+      connection: connectionReducer,
+      turnCompletion: turnCompletionReducer,
+    },
+    preloadedState: {
+      tabs: {
+        tabs: [{
+          id: 'tab-1',
+          createRequestId: 'req-1',
+          title: 'Test',
+          status: 'running' as const,
+          mode: 'shell' as const,
+          shell: 'system' as const,
+          terminalId: 'term-1',
+          createdAt: Date.now(),
+        }],
+        activeTabId: 'tab-1',
+        renameRequestTabId: null,
+      },
+      panes: {
+        layouts: { 'tab-1': { type: 'leaf' as const, id: 'pane-1', content: paneContent } },
+        activePane: { 'tab-1': 'pane-1' },
+        paneTitles: {},
+      },
+      settings: { settings: mergedSettings, loaded: true },
+      connection: { status: 'connected' as const, error: null },
+      turnCompletion: {
+        seq: 0,
+        lastEvent: null,
+        pendingEvents: [],
+        attentionByTab: {},
+        attentionByPane: {},
+      },
+    },
+  })
+}
+
+function getLinkHandler() {
+  const term = terminalInstances[terminalInstances.length - 1]
+  return term.options.linkHandler as {
+    activate: (event: MouseEvent, uri: string) => void
+    hover?: (event: MouseEvent, text: string, range: any) => void
+    leave?: (event: MouseEvent, text: string, range: any) => void
+  }
+}
+
+function getUrlLinkProvider() {
+  // URL link provider is registered second (after file path provider)
+  return registeredLinkProviders[registeredLinkProviders.length - 1] as {
+    provideLinks: (line: number, callback: (links: any[] | undefined) => void) => void
+  }
+}
+
+describe('TerminalView URL click behavior', () => {
+  let windowOpenSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    terminalInstances.length = 0
+    registeredLinkProviders.length = 0
+    windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
+    vi.stubGlobal('ResizeObserver', MockResizeObserver)
+  })
+
+  afterEach(() => {
+    cleanup()
+    windowOpenSpy.mockRestore()
+    vi.unstubAllGlobals()
+    clearHoveredUrl('pane-1')
+  })
+
+  it('OSC 8 linkHandler.activate with warnExternalLinks=false dispatches splitPane with browser content', async () => {
+    const store = createStore({ terminal: { ...defaultSettings.terminal, warnExternalLinks: false } })
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+    act(() => {
+      handler.activate(new MouseEvent('click'), 'https://example.com')
+    })
+
+    expect(store.getState().panes.layouts['tab-1'].type).toBe('leaf')
+
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+      if (layout.type === 'split') {
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: { kind: 'browser', url: 'https://example.com', devToolsOpen: false },
+        })
+      }
+    })
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+  })
+
+  it('OSC 8 linkHandler.activate with warnExternalLinks=true shows modal, confirm opens browser pane', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+    act(() => {
+      handler.activate(new MouseEvent('click'), 'https://example.com/page')
+    })
+
+    await waitFor(() => {
+      expect(screen.getByText('Open external link?')).toBeInTheDocument()
+    })
+
+    fireEvent.click(screen.getByText('Open link'))
+
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+      if (layout.type === 'split') {
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: { kind: 'browser', url: 'https://example.com/page', devToolsOpen: false },
+        })
+      }
+    })
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+  })
+
+  it('OSC 8 linkHandler.hover sets hovered URL in module and data attribute', async () => {
+    const store = createStore()
+
+    const { container } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+    expect(handler.hover).toBeDefined()
+
+    const mockRange = { start: { x: 1, y: 1 }, end: { x: 20, y: 1 } }
+    act(() => {
+      handler.hover!(new MouseEvent('mouseover'), 'https://hovered.example.com', mockRange)
+    })
+
+    expect(getHoveredUrl('pane-1')).toBe('https://hovered.example.com')
+    const wrapper = container.querySelector('[data-context="terminal"]') as HTMLElement
+    expect(wrapper?.dataset.hoveredUrl).toBe('https://hovered.example.com')
+  })
+
+  it('OSC 8 linkHandler.leave clears hovered URL from module and data attribute', async () => {
+    const store = createStore()
+
+    const { container } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+    const mockRange = { start: { x: 1, y: 1 }, end: { x: 20, y: 1 } }
+
+    // First hover
+    act(() => {
+      handler.hover!(new MouseEvent('mouseover'), 'https://hovered.example.com', mockRange)
+    })
+    expect(getHoveredUrl('pane-1')).toBe('https://hovered.example.com')
+
+    // Then leave
+    act(() => {
+      handler.leave!(new MouseEvent('mouseout'), 'https://hovered.example.com', mockRange)
+    })
+
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+    const wrapper = container.querySelector('[data-context="terminal"]') as HTMLElement
+    expect(wrapper?.dataset.hoveredUrl).toBeUndefined()
+  })
+
+  it('URL link provider activate with warnExternalLinks=false dispatches splitPane with browser content', async () => {
+    const store = createStore({ terminal: { ...defaultSettings.terminal, warnExternalLinks: false } })
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    const urlProvider = getUrlLinkProvider()
+    let links: any[] | undefined
+    urlProvider.provideLinks(1, (provided) => {
+      links = provided
+    })
+
+    expect(links).toBeDefined()
+    expect(links!.length).toBeGreaterThan(0)
+
+    act(() => {
+      links![0].activate(new MouseEvent('click'))
+    })
+
+    expect(store.getState().panes.layouts['tab-1'].type).toBe('leaf')
+
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+      if (layout.type === 'split') {
+        expect(layout.children[1]).toMatchObject({
+          type: 'leaf',
+          content: { kind: 'browser', url: 'https://detected.example.com', devToolsOpen: false },
+        })
+      }
+    })
+  })
+
+  it('URL link provider hover sets hovered URL in module and data attribute', async () => {
+    const store = createStore()
+
+    const { container } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    const urlProvider = getUrlLinkProvider()
+    let links: any[] | undefined
+    urlProvider.provideLinks(1, (provided) => {
+      links = provided
+    })
+
+    expect(links).toBeDefined()
+    act(() => {
+      links![0].hover(new MouseEvent('mouseover'), links![0].text)
+    })
+
+    expect(getHoveredUrl('pane-1')).toBe('https://detected.example.com')
+    const wrapper = container.querySelector('[data-context="terminal"]') as HTMLElement
+    expect(wrapper?.dataset.hoveredUrl).toBe('https://detected.example.com')
+  })
+
+  it('URL link provider leave clears hovered URL', async () => {
+    const store = createStore()
+
+    const { container } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    const urlProvider = getUrlLinkProvider()
+    let links: any[] | undefined
+    urlProvider.provideLinks(1, (provided) => {
+      links = provided
+    })
+
+    // Hover then leave
+    act(() => {
+      links![0].hover(new MouseEvent('mouseover'), links![0].text)
+    })
+    expect(getHoveredUrl('pane-1')).toBeDefined()
+
+    act(() => {
+      links![0].leave(new MouseEvent('mouseout'), links![0].text)
+    })
+
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+    const wrapper = container.querySelector('[data-context="terminal"]') as HTMLElement
+    expect(wrapper?.dataset.hoveredUrl).toBeUndefined()
+  })
+
+  it('URL link provider detects URLs in terminal buffer line', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    const urlProvider = getUrlLinkProvider()
+    let links: any[] | undefined
+    urlProvider.provideLinks(1, (provided) => {
+      links = provided
+    })
+
+    expect(links).toBeDefined()
+    expect(links!.length).toBe(1)
+    expect(links![0].text).toBe('https://detected.example.com')
+    // startIndex 6 in 'Visit https://detected.example.com here'
+    // x is 1-based: startIndex + 1 = 7
+    expect(links![0].range.start.x).toBe(7)
+  })
+
+  it('URL link provider returns undefined for lines with no URLs', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    // Override buffer line to return text without URLs
+    const term = terminalInstances[terminalInstances.length - 1]
+    term.buffer.active.getLine.mockReturnValueOnce({
+      translateToString: () => 'Just a normal line with /tmp/file.txt',
+    })
+
+    const urlProvider = getUrlLinkProvider()
+    let links: any[] | undefined
+    urlProvider.provideLinks(2, (provided) => {
+      links = provided
+    })
+
+    expect(links).toBeUndefined()
+  })
+
+  it('terminal dispose clears hovered URL', async () => {
+    const store = createStore()
+
+    const { unmount } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    // Set hovered URL via hover callback
+    const handler = getLinkHandler()
+    const mockRange = { start: { x: 1, y: 1 }, end: { x: 20, y: 1 } }
+    act(() => {
+      handler.hover!(new MouseEvent('mouseover'), 'https://hovered.example.com', mockRange)
+    })
+    expect(getHoveredUrl('pane-1')).toBe('https://hovered.example.com')
+
+    // Unmount
+    unmount()
+
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+  })
+
+  it('hover state is cleared when terminal tab becomes hidden', async () => {
+    const store = createStore()
+
+    const { rerender } = render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    // Set hovered URL via hover callback
+    const handler = getLinkHandler()
+    const mockRange = { start: { x: 1, y: 1 }, end: { x: 20, y: 1 } }
+    act(() => {
+      handler.hover!(new MouseEvent('mouseover'), 'https://hovered.example.com', mockRange)
+    })
+    expect(getHoveredUrl('pane-1')).toBe('https://hovered.example.com')
+
+    // Re-render with hidden=true
+    rerender(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={true} />
+      </Provider>
+    )
+
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+  })
+
+  it('OSC 8 linkHandler.activate with non-http scheme does not open browser pane', async () => {
+    const store = createStore({ terminal: { ...defaultSettings.terminal, warnExternalLinks: false } })
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+
+    // javascript: URI should be silently blocked
+    act(() => {
+      handler.activate(new MouseEvent('click'), 'javascript:alert(1)')
+    })
+
+    const layout = store.getState().panes.layouts['tab-1']
+    expect(layout.type).toBe('leaf')
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+
+    // data: URI should be silently blocked
+    act(() => {
+      handler.activate(new MouseEvent('click'), 'data:text/html,<h1>hi</h1>')
+    })
+
+    const layout2 = store.getState().panes.layouts['tab-1']
+    expect(layout2.type).toBe('leaf')
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+  })
+
+  it('OSC 8 linkHandler.activate with https scheme opens browser pane normally', async () => {
+    const store = createStore({ terminal: { ...defaultSettings.terminal, warnExternalLinks: false } })
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(terminalInstances).toHaveLength(1)
+    })
+
+    const handler = getLinkHandler()
+    act(() => {
+      handler.activate(new MouseEvent('click'), 'https://safe.example.com')
+    })
+
+    expect(store.getState().panes.layouts['tab-1'].type).toBe('leaf')
+
+    await waitFor(() => {
+      const layout = store.getState().panes.layouts['tab-1']
+      expect(layout.type).toBe('split')
+    })
+    expect(windowOpenSpy).not.toHaveBeenCalled()
+  })
+
+  it('file path link provider is registered before URL link provider', async () => {
+    const store = createStore()
+
+    render(
+      <Provider store={store}>
+        <TerminalView tabId="tab-1" paneId="pane-1" paneContent={paneContent} hidden={false} />
+      </Provider>
+    )
+
+    await waitFor(() => {
+      expect(registeredLinkProviders.length).toBeGreaterThanOrEqual(2)
+    })
+
+    // First provider (file path) should detect file paths
+    const fileProvider = registeredLinkProviders[0]
+
+    // Override buffer to return a file path
+    const term = terminalInstances[terminalInstances.length - 1]
+    term.buffer.active.getLine.mockReturnValueOnce({
+      translateToString: () => '/tmp/example.txt',
+    })
+
+    let fileLinks: any[] | undefined
+    fileProvider.provideLinks(1, (provided: any) => {
+      fileLinks = provided
+    })
+
+    expect(fileLinks).toBeDefined()
+    expect(fileLinks![0].text).toBe('/tmp/example.txt')
+
+    // Second provider (URL) should detect URLs
+    const urlProvider = registeredLinkProviders[1]
+    // Use original getLine mock (returns URL text)
+    let urlLinks: any[] | undefined
+    urlProvider.provideLinks(1, (provided: any) => {
+      urlLinks = provided
+    })
+
+    expect(urlLinks).toBeDefined()
+    expect(urlLinks![0].text).toBe('https://detected.example.com')
+  })
+})
diff --git a/test/unit/client/components/context-menu/context-menu-utils.test.ts b/test/unit/client/components/context-menu/context-menu-utils.test.ts
new file mode 100644
index 00000000..a8fdaa79
--- /dev/null
+++ b/test/unit/client/components/context-menu/context-menu-utils.test.ts
@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest'
+import { parseContextTarget } from '@/components/context-menu/context-menu-utils'
+import { ContextIds } from '@/components/context-menu/context-menu-constants'
+
+describe('parseContextTarget', () => {
+  it('parseContextTarget for Terminal returns hoveredUrl from dataset', () => {
+    const result = parseContextTarget(ContextIds.Terminal, {
+      tabId: 'tab-1',
+      paneId: 'pane-1',
+      hoveredUrl: 'https://example.com',
+    })
+    expect(result).toEqual({
+      kind: 'terminal',
+      tabId: 'tab-1',
+      paneId: 'pane-1',
+      hoveredUrl: 'https://example.com',
+    })
+  })
+
+  it('parseContextTarget for Terminal returns hoveredUrl as undefined when not in dataset', () => {
+    const result = parseContextTarget(ContextIds.Terminal, {
+      tabId: 'tab-1',
+      paneId: 'pane-1',
+    })
+    expect(result).toEqual({
+      kind: 'terminal',
+      tabId: 'tab-1',
+      paneId: 'pane-1',
+      hoveredUrl: undefined,
+    })
+  })
+
+  it('parseContextTarget for Terminal returns null when tabId is missing', () => {
+    const result = parseContextTarget(ContextIds.Terminal, {
+      paneId: 'pane-1',
+    })
+    expect(result).toBeNull()
+  })
+
+  it('parseContextTarget for Terminal returns null when paneId is missing', () => {
+    const result = parseContextTarget(ContextIds.Terminal, {
+      tabId: 'tab-1',
+    })
+    expect(result).toBeNull()
+  })
+
+  it('parseContextTarget for Global returns global target', () => {
+    const result = parseContextTarget(ContextIds.Global, {})
+    expect(result).toEqual({ kind: 'global' })
+  })
+
+  it('parseContextTarget for Tab returns tab target with tabId', () => {
+    const result = parseContextTarget(ContextIds.Tab, { tabId: 'tab-1' })
+    expect(result).toEqual({ kind: 'tab', tabId: 'tab-1' })
+  })
+})
diff --git a/test/unit/client/components/context-menu/menu-defs.test.ts b/test/unit/client/components/context-menu/menu-defs.test.ts
index 08020b16..94a24f93 100644
--- a/test/unit/client/components/context-menu/menu-defs.test.ts
+++ b/test/unit/client/components/context-menu/menu-defs.test.ts
@@ -51,6 +51,16 @@ function createMockActions(): MenuActions {
     copyAgentChatDiffNew: vi.fn(),
     copyAgentChatDiffOld: vi.fn(),
     copyAgentChatFilePath: vi.fn(),
+    refreshTab: vi.fn(),
+    refreshPane: vi.fn(),
+    replacePane: vi.fn(),
+    reopenClosedTab: vi.fn(),
+    generateSessionTitle: vi.fn(),
+    showKeyboardShortcuts: vi.fn(),
+    openUrlInPane: vi.fn(),
+    openUrlInTab: vi.fn(),
+    openUrlInBrowser: vi.fn(),
+    copyUrl: vi.fn(),
   }
 }
 
@@ -81,6 +91,7 @@ function createMockContext(actions: MenuActions): MenuBuildContext {
     contextElement: null,
     clickTarget: null,
     actions,
+    aiEnabled: false,
     platform: null,
   }
 }
@@ -290,3 +301,104 @@ describe('buildMenuItems — agent-chat context-sensitive items', () => {
     expect(items[sessionIdx - 1]?.type).toBe('separator')
   })
 })
+
+describe('buildMenuItems — terminal context with hoveredUrl', () => {
+  function buildTerminalItems(hoveredUrl?: string) {
+    const mockActions = createMockActions()
+    const mockContext = createMockContext(mockActions)
+    ;(mockActions.getTerminalActions as ReturnType<typeof vi.fn>).mockReturnValue({
+      hasSelection: () => false,
+      copySelection: vi.fn(),
+      paste: vi.fn(),
+      selectAll: vi.fn(),
+      clearScrollback: vi.fn(),
+      reset: vi.fn(),
+      scrollToBottom: vi.fn(),
+      openSearch: vi.fn(),
+    })
+    const target: ContextTarget = { kind: 'terminal', tabId: 'tab1', paneId: 'pane1', hoveredUrl }
+    const items = buildMenuItems(target, mockContext)
+    return { items, mockActions }
+  }
+
+  it('terminal target with hoveredUrl includes URL menu items at the top', () => {
+    const { items } = buildTerminalItems('https://example.com')
+    const actionItems = items.filter(i => i.type === 'item')
+    const ids = actionItems.map(i => i.id)
+    expect(ids[0]).toBe('url-open-pane')
+    expect(ids[1]).toBe('url-open-tab')
+    expect(ids[2]).toBe('url-open-browser')
+    expect(ids[3]).toBe('url-copy')
+    // After URL items there should be a separator, then clipboard items
+    const urlSepIdx = items.findIndex(i => i.type === 'separator' && i.id === 'url-sep')
+    expect(urlSepIdx).toBeGreaterThan(0)
+  })
+
+  it('terminal target without hoveredUrl has no URL menu items', () => {
+    const { items } = buildTerminalItems()
+    const ids = items.filter(i => i.type === 'item').map(i => i.id)
+    expect(ids).not.toContain('url-open-pane')
+    expect(ids).not.toContain('url-open-tab')
+    expect(ids).not.toContain('url-open-browser')
+    expect(ids).not.toContain('url-copy')
+    // First item should be terminal-copy
+    expect(ids[0]).toBe('terminal-copy')
+  })
+
+  it('url-open-pane item calls openUrlInPane with correct args', () => {
+    const { items, mockActions } = buildTerminalItems('https://test.url')
+    const item = items.find(i => i.type === 'item' && i.id === 'url-open-pane')
+    expect(item).toBeDefined()
+    if (item?.type === 'item') item.onSelect()
+    expect(mockActions.openUrlInPane).toHaveBeenCalledWith('tab1', 'pane1', 'https://test.url')
+  })
+
+  it('url-open-tab item calls openUrlInTab with correct args', () => {
+    const { items, mockActions } = buildTerminalItems('https://test.url')
+    const item = items.find(i => i.type === 'item' && i.id === 'url-open-tab')
+    expect(item).toBeDefined()
+    if (item?.type === 'item') item.onSelect()
+    expect(mockActions.openUrlInTab).toHaveBeenCalledWith('https://test.url')
+  })
+
+  it('url-open-browser item calls openUrlInBrowser with correct args', () => {
+    const { items, mockActions } = buildTerminalItems('https://test.url')
+    const item = items.find(i => i.type === 'item' && i.id === 'url-open-browser')
+    expect(item).toBeDefined()
+    if (item?.type === 'item') item.onSelect()
+    expect(mockActions.openUrlInBrowser).toHaveBeenCalledWith('https://test.url')
+  })
+
+  it('url-copy item calls copyUrl with correct args', () => {
+    const { items, mockActions } = buildTerminalItems('https://test.url')
+    const item = items.find(i => i.type === 'item' && i.id === 'url-copy')
+    expect(item).toBeDefined()
+    if (item?.type === 'item') item.onSelect()
+    expect(mockActions.copyUrl).toHaveBeenCalledWith('https://test.url')
+  })
+
+  it('URL items have correct labels', () => {
+    const { items } = buildTerminalItems('https://example.com')
+    const urlItems = items.filter(i => i.type === 'item' && i.id.startsWith('url-'))
+    expect(urlItems).toHaveLength(4)
+    const labels = urlItems.map(i => i.type === 'item' ? i.label : '')
+    expect(labels).toEqual([
+      'Open URL in pane',
+      'Open URL in new tab',
+      'Open in external browser',
+      'Copy URL',
+    ])
+  })
+
+  it('existing terminal menu items still present after URL items', () => {
+    const { items } = buildTerminalItems('https://example.com')
+    const ids = items.filter(i => i.type === 'item').map(i => i.id)
+    expect(ids).toContain('terminal-copy')
+    expect(ids).toContain('terminal-paste')
+    expect(ids).toContain('terminal-select-all')
+    expect(ids).toContain('terminal-search')
+    expect(ids).toContain('terminal-clear')
+    expect(ids).toContain('terminal-reset')
+    expect(ids).toContain('replace-pane')
+  })
+})
diff --git a/test/unit/client/lib/terminal-hovered-url.test.ts b/test/unit/client/lib/terminal-hovered-url.test.ts
new file mode 100644
index 00000000..6f52a5a6
--- /dev/null
+++ b/test/unit/client/lib/terminal-hovered-url.test.ts
@@ -0,0 +1,48 @@
+import { describe, it, expect, afterEach } from 'vitest'
+import { setHoveredUrl, getHoveredUrl, clearHoveredUrl } from '@/lib/terminal-hovered-url'
+
+describe('terminal-hovered-url', () => {
+  afterEach(() => {
+    // Clean up any state left by tests
+    clearHoveredUrl('pane-1')
+    clearHoveredUrl('pane-2')
+    clearHoveredUrl('pane-x')
+    clearHoveredUrl('nonexistent')
+  })
+
+  it('getHoveredUrl returns undefined for unknown paneId', () => {
+    expect(getHoveredUrl('pane-x')).toBeUndefined()
+  })
+
+  it('setHoveredUrl stores a URL for a pane', () => {
+    setHoveredUrl('pane-1', 'https://a.com')
+    expect(getHoveredUrl('pane-1')).toBe('https://a.com')
+  })
+
+  it('setHoveredUrl overwrites a previous URL for the same pane', () => {
+    setHoveredUrl('pane-1', 'https://first.com')
+    setHoveredUrl('pane-1', 'https://second.com')
+    expect(getHoveredUrl('pane-1')).toBe('https://second.com')
+  })
+
+  it('clearHoveredUrl removes the stored URL', () => {
+    setHoveredUrl('pane-1', 'https://a.com')
+    clearHoveredUrl('pane-1')
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+  })
+
+  it('clearHoveredUrl on unknown paneId is a no-op', () => {
+    expect(() => clearHoveredUrl('nonexistent')).not.toThrow()
+  })
+
+  it('multiple panes are tracked independently', () => {
+    setHoveredUrl('pane-1', 'https://one.com')
+    setHoveredUrl('pane-2', 'https://two.com')
+    expect(getHoveredUrl('pane-1')).toBe('https://one.com')
+    expect(getHoveredUrl('pane-2')).toBe('https://two.com')
+
+    clearHoveredUrl('pane-1')
+    expect(getHoveredUrl('pane-1')).toBeUndefined()
+    expect(getHoveredUrl('pane-2')).toBe('https://two.com')
+  })
+})
diff --git a/test/unit/client/lib/url-utils.test.ts b/test/unit/client/lib/url-utils.test.ts
new file mode 100644
index 00000000..684cc9df
--- /dev/null
+++ b/test/unit/client/lib/url-utils.test.ts
@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest'
+import { findUrls } from '@/lib/url-utils'
+
+describe('findUrls', () => {
+  it('finds a simple https URL', () => {
+    const results = findUrls('Visit https://example.com for info')
+    expect(results).toHaveLength(1)
+    expect(results[0]).toEqual({ url: 'https://example.com', startIndex: 6, endIndex: 25 })
+  })
+
+  it('finds a simple http URL', () => {
+    const results = findUrls('See http://example.org/page')
+    expect(results).toHaveLength(1)
+    expect(results[0]).toEqual({ url: 'http://example.org/page', startIndex: 4, endIndex: 27 })
+  })
+
+  it('finds multiple URLs on one line', () => {
+    const results = findUrls('Links: https://a.com and https://b.com/path')
+    expect(results).toHaveLength(2)
+    expect(results[0].url).toBe('https://a.com')
+    expect(results[1].url).toBe('https://b.com/path')
+  })
+
+  it('strips trailing period from URL', () => {
+    const results = findUrls('Go to https://example.com/path.')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/path')
+  })
+
+  it('strips trailing comma', () => {
+    const results = findUrls('See https://example.com/path, then continue')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/path')
+  })
+
+  it('strips trailing semicolon', () => {
+    const results = findUrls('URL: https://example.com;')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com')
+  })
+
+  it('strips trailing closing parenthesis', () => {
+    const results = findUrls('(see https://example.com/page)')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/page')
+  })
+
+  it('strips trailing exclamation mark', () => {
+    const results = findUrls('Check https://example.com!')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com')
+  })
+
+  it('preserves URL with query string', () => {
+    const results = findUrls('https://example.com/search?q=test&page=1')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/search?q=test&page=1')
+  })
+
+  it('preserves URL with fragment', () => {
+    const results = findUrls('https://example.com/docs#section-2')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/docs#section-2')
+  })
+
+  it('preserves URL with port number', () => {
+    const results = findUrls('http://localhost:3000/api/health')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('http://localhost:3000/api/health')
+  })
+
+  it('preserves URL with path and trailing slash', () => {
+    const results = findUrls('https://example.com/path/')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/path/')
+  })
+
+  it('returns empty array for line with no URLs', () => {
+    expect(findUrls('Just a normal line of text')).toEqual([])
+  })
+
+  it('does not match ftp or other schemes', () => {
+    expect(findUrls('Download from ftp://files.example.com/data')).toEqual([])
+  })
+
+  it('handles URL at start of line', () => {
+    const results = findUrls('https://example.com is great')
+    expect(results).toHaveLength(1)
+    expect(results[0].startIndex).toBe(0)
+  })
+
+  it('handles URL at end of line', () => {
+    const results = findUrls('Visit https://example.com')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com')
+    expect(results[0].endIndex).toBe(25)
+  })
+
+  it('handles URL that is the entire line', () => {
+    const line = 'https://example.com/path/to/resource'
+    const results = findUrls(line)
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe(line)
+    expect(results[0].startIndex).toBe(0)
+    expect(results[0].endIndex).toBe(line.length)
+  })
+
+  it('does not match bare domains without scheme', () => {
+    expect(findUrls('Go to example.com for info')).toEqual([])
+  })
+
+  it('handles multiple trailing punctuation characters', () => {
+    const results = findUrls('See https://example.com/page.),')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/page')
+  })
+
+  it('preserves URL with encoded characters', () => {
+    const results = findUrls('https://example.com/path%20with%20spaces')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/path%20with%20spaces')
+  })
+
+  it('preserves balanced parentheses in Wikipedia-style URLs', () => {
+    const results = findUrls('See https://en.wikipedia.org/wiki/Foo_(bar) for details')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://en.wikipedia.org/wiki/Foo_(bar)')
+  })
+
+  it('preserves nested balanced parentheses', () => {
+    const results = findUrls('https://example.com/path_(a_(b))')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/path_(a_(b))')
+  })
+
+  it('strips unbalanced trailing paren when URL has no open paren', () => {
+    const results = findUrls('(see https://example.com/page)')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://example.com/page')
+  })
+
+  it('strips trailing punctuation after balanced parens', () => {
+    const results = findUrls('https://en.wikipedia.org/wiki/Foo_(bar).')
+    expect(results).toHaveLength(1)
+    expect(results[0].url).toBe('https://en.wikipedia.org/wiki/Foo_(bar)')
+  })
+})
diff --git a/test/unit/client/lib/ws-client.test.ts b/test/unit/client/lib/ws-client.test.ts
index 55ecb36c..7c43a872 100644
--- a/test/unit/client/lib/ws-client.test.ts
+++ b/test/unit/client/lib/ws-client.test.ts
@@ -367,8 +367,11 @@ describe('WsClient.connect', () => {
 
     await expect(p).rejects.toThrow(/Handshake timeout/i)
 
-    // Should schedule a reconnect attempt (baseReconnectDelay = 1000).
-    expect(setTimeoutSpy.mock.calls.some((call) => call[1] === 1000)).toBe(true)
+    // Should schedule a reconnect attempt around baseReconnectDelay (1000ms ± jitter)
+    const reconnectDelays = setTimeoutSpy.mock.calls
+      .map((call) => call[1])
+      .filter((d): d is number => typeof d === 'number' && d >= 800 && d <= 1400)
+    expect(reconnectDelays.length).toBeGreaterThan(0)
   })
 
   it('treats BACKPRESSURE as transient and schedules reconnect with a minimum delay', async () => {
@@ -403,11 +406,15 @@ describe('WsClient.connect', () => {
       .map((call) => call[1])
       .filter((d): d is number => typeof d === 'number' && d < 10000)
 
-    expect(reconnectDelays).toContain(1000)
-    expect(reconnectDelays.every((delay) => delay < 5000)).toBe(true)
+    // First reconnect delay should be around 1000ms (with jitter ±20%)
+    expect(reconnectDelays.length).toBeGreaterThan(0)
+    expect(reconnectDelays[0]).toBeGreaterThanOrEqual(800)
+    expect(reconnectDelays[0]).toBeLessThanOrEqual(1400)
+    // All delays capped at max (4000ms + jitter ceiling)
+    expect(reconnectDelays.every((delay) => delay <= 4800)).toBe(true)
   })
 
-  it('treats SERVER_SHUTDOWN (4009) as transient and resets backoff for fast reconnect', async () => {
+  it('treats SERVER_SHUTDOWN (4009) as transient and uses fast reconnect', async () => {
     const setTimeoutSpy = vi.spyOn(window, 'setTimeout')
 
     const c = new WsClient('ws://example/ws')
@@ -419,14 +426,14 @@ describe('WsClient.connect', () => {
 
     await expect(p).rejects.toThrow(/Server restarting/i)
 
-    // Should schedule a reconnect at base delay (1000ms) since backoff is reset.
-    // Filter out the connection timeout (10000ms) which is unrelated.
+    // Should schedule a fast reconnect (500ms base with jitter)
     const reconnectDelays = setTimeoutSpy.mock.calls
       .map((call) => call[1])
       .filter((d): d is number => typeof d === 'number' && d < 10000)
-    expect(reconnectDelays).toContain(1000)
-    // No exponential backoff — max reconnect delay should be 1000ms
-    expect(Math.max(...reconnectDelays)).toBe(1000)
+    expect(reconnectDelays.length).toBeGreaterThan(0)
+    // Post-shutdown base is 500ms, with jitter ±20%: 400-700ms
+    expect(reconnectDelays[0]).toBeGreaterThanOrEqual(400)
+    expect(reconnectDelays[0]).toBeLessThanOrEqual(700)
   })
 
   it('treats protocol version mismatch as fatal and does not reconnect', async () => {
diff --git a/test/unit/client/store/connectionSlice.test.ts b/test/unit/client/store/connectionSlice.test.ts
index 5ad63e96..01f8124e 100644
--- a/test/unit/client/store/connectionSlice.test.ts
+++ b/test/unit/client/store/connectionSlice.test.ts
@@ -6,6 +6,9 @@ import connectionReducer, {
   setPlatform,
   setAvailableClis,
   setFeatureFlags,
+  setBootId,
+  setServerRestarted,
+  setLiveTerminalIds,
   ConnectionState,
   ConnectionStatus,
 } from '../../../../src/store/connectionSlice'
@@ -363,6 +366,32 @@ describe('connectionSlice', () => {
     })
   })
 
+  describe('bootId and server restart detection', () => {
+    it('stores bootId via setBootId', () => {
+      const state = connectionReducer(undefined, setBootId('boot-abc'))
+      expect(state.bootId).toBe('boot-abc')
+    })
+
+    it('tracks server restart flag', () => {
+      let state = connectionReducer(undefined, setServerRestarted(true))
+      expect(state.serverRestarted).toBe(true)
+
+      state = connectionReducer(state, setServerRestarted(false))
+      expect(state.serverRestarted).toBe(false)
+    })
+
+    it('stores live terminal IDs', () => {
+      const state = connectionReducer(undefined, setLiveTerminalIds(['t1', 't2']))
+      expect(state.liveTerminalIds).toEqual(['t1', 't2'])
+    })
+
+    it('clears live terminal IDs', () => {
+      let state = connectionReducer(undefined, setLiveTerminalIds(['t1']))
+      state = connectionReducer(state, setLiveTerminalIds(undefined))
+      expect(state.liveTerminalIds).toBeUndefined()
+    })
+  })
+
   describe('state transitions', () => {
     it('handles typical connection lifecycle', () => {
       const now = Date.now()
diff --git a/test/unit/client/store/crossTabSync.test.ts b/test/unit/client/store/crossTabSync.test.ts
index 9bb6cedb..a08ac34d 100644
--- a/test/unit/client/store/crossTabSync.test.ts
+++ b/test/unit/client/store/crossTabSync.test.ts
@@ -736,4 +736,46 @@ describe('crossTabSync', () => {
       .filter((a: any) => a?.type === 'tabs/hydrateTabs')
     expect(hydrateCalls).toHaveLength(2)
   })
+
+  it('hydrates paired panes when tabs event arrives first', () => {
+    const store = configureStore({
+      reducer: { tabs: tabsReducer, panes: panesReducer },
+    })
+
+    // Install sync first (captures current empty localStorage as baseline)
+    cleanups.push(installCrossTabSync(store as any))
+
+    const tabsRaw = JSON.stringify({
+      version: 1,
+      tabs: {
+        activeTabId: 't1',
+        tabs: [
+          { id: 't1', title: 'T1', mode: 'shell' },
+          { id: 't2', title: 'T2', mode: 'shell' },
+        ],
+      },
+    })
+
+    const panesRaw = JSON.stringify({
+      version: 6,
+      layouts: {
+        't1': { type: 'leaf', id: 'p1', content: { kind: 'terminal', mode: 'shell', createRequestId: 'r1', status: 'running' } },
+        't2': { type: 'leaf', id: 'p2', content: { kind: 'terminal', mode: 'shell', createRequestId: 'r2', status: 'running' } },
+      },
+      activePane: { 't1': 'p1', 't2': 'p2' },
+      paneTitles: {},
+    })
+
+    // Simulate flush() in another tab: both are written to localStorage
+    localStorage.setItem(TABS_STORAGE_KEY, tabsRaw)
+    localStorage.setItem(PANES_STORAGE_KEY, panesRaw)
+
+    // Only the tabs event arrives — panes should also be hydrated from localStorage
+    window.dispatchEvent(new StorageEvent('storage', { key: TABS_STORAGE_KEY, newValue: tabsRaw }))
+
+    // Both tabs and panes should be hydrated consistently
+    expect(store.getState().tabs.tabs.map((t: any) => t.id)).toEqual(['t1', 't2'])
+    expect(store.getState().panes.layouts).toHaveProperty('t1')
+    expect(store.getState().panes.layouts).toHaveProperty('t2')
+  })
 })
diff --git a/test/unit/client/store/panesSlice.test.ts b/test/unit/client/store/panesSlice.test.ts
index 9ac5be4b..42bbd526 100644
--- a/test/unit/client/store/panesSlice.test.ts
+++ b/test/unit/client/store/panesSlice.test.ts
@@ -21,6 +21,7 @@ import panesReducer, {
   requestPaneRename,
   clearPaneRenameRequest,
   toggleZoom,
+  clearDeadTerminals,
   PanesState,
 } from '../../../../src/store/panesSlice'
 import type { PaneNode, PaneContent, TerminalPaneContent, BrowserPaneContent, EditorPaneContent, ExtensionPaneContent } from '../../../../src/store/paneTypes'
@@ -2245,13 +2246,99 @@ describe('panesSlice', () => {
 
       const next = panesReducer(localState, hydratePanes(incoming))
 
-      expect(next.layouts['tab-1']).toEqual(localState.layouts['tab-1'])
+      const leaf = next.layouts['tab-1'] as Extract<PaneNode, { type: 'leaf' }>
+      expect(leaf.content.kind).toBe('terminal')
+      expect((leaf.content as TerminalPaneContent).terminalId).toBe('local-terminal-1')
       expect(next.activePane['tab-1']).toBe('pane-1')
       expect(next.paneTitles['tab-1']).toEqual({ 'pane-1': 'Local title' })
       expect(next.paneTitleSetByUser['tab-1']).toEqual({ 'pane-1': true })
     })
   })
 
+  describe('clearDeadTerminals', () => {
+    it('clears terminal IDs not in the live list', () => {
+      const state: PanesState = {
+        layouts: {
+          'tab-1': {
+            type: 'leaf',
+            id: 'p1',
+            content: { kind: 'terminal', mode: 'shell', createRequestId: 'r1', status: 'running', terminalId: 'alive-1' },
+          } as any,
+          'tab-2': {
+            type: 'leaf',
+            id: 'p2',
+            content: { kind: 'terminal', mode: 'shell', createRequestId: 'r2', status: 'running', terminalId: 'dead-1' },
+          } as any,
+          'tab-3': {
+            type: 'leaf',
+            id: 'p3',
+            content: { kind: 'browser', url: 'https://example.com' },
+          } as any,
+        },
+        activePane: {},
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+        refreshRequestsByPane: {},
+      }
+
+      const next = panesReducer(state, clearDeadTerminals({ liveTerminalIds: ['alive-1'] }))
+
+      // alive-1 should be preserved
+      const leaf1 = next.layouts['tab-1'] as Extract<PaneNode, { type: 'leaf' }>
+      expect((leaf1.content as TerminalPaneContent).terminalId).toBe('alive-1')
+      expect((leaf1.content as TerminalPaneContent).status).toBe('running')
+
+      // dead-1 should be cleared with a new createRequestId to trigger re-creation
+      const leaf2 = next.layouts['tab-2'] as Extract<PaneNode, { type: 'leaf' }>
+      expect((leaf2.content as TerminalPaneContent).terminalId).toBeUndefined()
+      expect((leaf2.content as TerminalPaneContent).status).toBe('creating')
+      expect((leaf2.content as TerminalPaneContent).createRequestId).not.toBe('r2')
+
+      // browser pane should be untouched
+      const leaf3 = next.layouts['tab-3'] as Extract<PaneNode, { type: 'leaf' }>
+      expect(leaf3.content.kind).toBe('browser')
+    })
+
+    it('generates new createRequestIds to trigger TerminalView effect re-run', () => {
+      const state: PanesState = {
+        layouts: {
+          'tab-1': {
+            type: 'leaf',
+            id: 'p1',
+            content: { kind: 'terminal', mode: 'shell', createRequestId: 'original-req-1', status: 'running', terminalId: 'dead-1' },
+          } as any,
+          'tab-2': {
+            type: 'leaf',
+            id: 'p2',
+            content: { kind: 'terminal', mode: 'claude', createRequestId: 'original-req-2', status: 'running', terminalId: 'dead-2' },
+          } as any,
+        },
+        activePane: {},
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+        refreshRequestsByPane: {},
+      }
+
+      const next = panesReducer(state, clearDeadTerminals({ liveTerminalIds: [] }))
+
+      const leaf1 = next.layouts['tab-1'] as Extract<PaneNode, { type: 'leaf' }>
+      expect((leaf1.content as TerminalPaneContent).createRequestId).not.toBe('original-req-1')
+      expect((leaf1.content as TerminalPaneContent).terminalId).toBeUndefined()
+      expect((leaf1.content as TerminalPaneContent).status).toBe('creating')
+
+      const leaf2 = next.layouts['tab-2'] as Extract<PaneNode, { type: 'leaf' }>
+      expect((leaf2.content as TerminalPaneContent).createRequestId).not.toBe('original-req-2')
+      expect((leaf2.content as TerminalPaneContent).terminalId).toBeUndefined()
+      expect((leaf2.content as TerminalPaneContent).status).toBe('creating')
+    })
+  })
+
   describe('PaneContent types', () => {
     it('TerminalPaneContent has required lifecycle fields', () => {
       const content: TerminalPaneContent = {
@@ -2408,6 +2495,89 @@ describe('panesSlice', () => {
       })
     })
 
+    it('preserves local terminal pane when incoming is browser kind', () => {
+      const terminalContent: TerminalPaneContent = {
+        kind: 'terminal',
+        createRequestId: 'req-1',
+        status: 'running',
+        mode: 'shell',
+        terminalId: 'term-live',
+      }
+      const browserContent: PaneContent = {
+        kind: 'browser',
+        url: 'https://example.com',
+      }
+
+      const localState = panesReducer(
+        initialState,
+        initLayout({ tabId: 'tab-xk', content: terminalContent })
+      )
+
+      const paneId = (localState.layouts['tab-xk'] as any).id
+
+      const incoming: PanesState = {
+        layouts: {
+          'tab-xk': {
+            type: 'leaf',
+            id: paneId,
+            content: browserContent,
+          },
+        },
+        activePane: localState.activePane,
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+      }
+
+      const merged = panesReducer(localState, hydratePanes(incoming))
+      const leaf = merged.layouts['tab-xk'] as Extract<PaneNode, { type: 'leaf' }>
+      expect(leaf.content.kind).toBe('terminal')
+      expect((leaf.content as TerminalPaneContent).terminalId).toBe('term-live')
+    })
+
+    it('preserves local browser pane when incoming is terminal kind', () => {
+      const browserContent: PaneContent = {
+        kind: 'browser',
+        url: 'https://example.com',
+      }
+      const terminalContent: TerminalPaneContent = {
+        kind: 'terminal',
+        createRequestId: 'req-2',
+        status: 'running',
+        mode: 'shell',
+        terminalId: 'term-other',
+      }
+
+      const localState = panesReducer(
+        initialState,
+        initLayout({ tabId: 'tab-xk2', content: browserContent })
+      )
+
+      const paneId = (localState.layouts['tab-xk2'] as any).id
+
+      const incoming: PanesState = {
+        layouts: {
+          'tab-xk2': {
+            type: 'leaf',
+            id: paneId,
+            content: terminalContent,
+          },
+        },
+        activePane: localState.activePane,
+        paneTitles: {},
+        paneTitleSetByUser: {},
+        renameRequestTabId: null,
+        renameRequestPaneId: null,
+        zoomedPane: {},
+      }
+
+      const merged = panesReducer(localState, hydratePanes(incoming))
+      const leaf = merged.layouts['tab-xk2'] as Extract<PaneNode, { type: 'leaf' }>
+      expect(leaf.content.kind).toBe('browser')
+    })
+
     it('survives mergeTerminalState when extension pane exists locally and remotely', () => {
       const extensionContent: PaneContent = {
         kind: 'extension',
diff --git a/test/unit/client/store/selectors/sidebarSelectors.test.ts b/test/unit/client/store/selectors/sidebarSelectors.test.ts
index cf2a7da7..ce89860b 100644
--- a/test/unit/client/store/selectors/sidebarSelectors.test.ts
+++ b/test/unit/client/store/selectors/sidebarSelectors.test.ts
@@ -1,5 +1,13 @@
 import { describe, it, expect } from 'vitest'
 import type { SidebarSessionItem } from '@/store/selectors/sidebarSelectors'
+import type { ProjectGroup, CodingCliSession } from '@/store/types'
+
+import {
+  buildSessionItems,
+  filterSessionItemsByVisibility,
+  makeSelectSortedSessionItems,
+  sortSessionItems,
+} from '@/store/selectors/sidebarSelectors'
 
 // Helper to create test session items
 function createSessionItem(overrides: Partial<SidebarSessionItem>): SidebarSessionItem {
@@ -17,9 +25,77 @@ function createSessionItem(overrides: Partial<SidebarSessionItem>): SidebarSessi
   }
 }
 
-// Import the sort function and buildSessionItems for testing
-import { sortSessionItems, buildSessionItems, filterSessionItemsByVisibility } from '@/store/selectors/sidebarSelectors'
-import type { CodingCliSession, ProjectGroup } from '@/store/types'
+function createFallbackTab(tabId: string, sessionId: string, title: string, cwd: string, mode: 'claude' | 'codex' = 'codex') {
+  const paneId = `pane-${tabId}`
+  return {
+    tab: { id: tabId, title, mode, resumeSessionId: sessionId, createdAt: 1_000 },
+    paneId,
+    layout: {
+      type: 'leaf',
+      id: paneId,
+      content: {
+        kind: 'terminal',
+        mode,
+        status: 'running',
+        createRequestId: `req-${tabId}`,
+        resumeSessionId: sessionId,
+        initialCwd: cwd,
+      },
+    },
+  }
+}
+
+function createSelectorState(options: {
+  projects?: ProjectGroup[]
+  tabs?: any[]
+  panes?: any
+  sortMode?: 'recency' | 'activity' | 'recency-pinned' | 'project'
+  query?: string
+  searchTier?: 'title' | 'userMessages' | 'fullText'
+  appliedQuery?: string
+  appliedSearchTier?: 'title' | 'userMessages' | 'fullText'
+  sessionActivity?: Record<string, number>
+} = {}) {
+  const projects = options.projects ?? []
+  return {
+    sessions: {
+      projects,
+      windows: {
+        sidebar: {
+          projects,
+          query: options.query ?? '',
+          searchTier: options.searchTier ?? 'title',
+          appliedQuery: options.appliedQuery,
+          appliedSearchTier: options.appliedSearchTier,
+        },
+      },
+    },
+    tabs: {
+      tabs: options.tabs ?? [],
+    },
+    panes: options.panes ?? {
+      layouts: {},
+      activePane: {},
+      paneTitles: {},
+    },
+    settings: {
+      settings: {
+        sidebar: {
+          sortMode: options.sortMode ?? 'activity',
+          showSubagents: true,
+          ignoreCodexSubagents: false,
+          showNoninteractiveSessions: true,
+          hideEmptySessions: false,
+          excludeFirstChatSubstrings: [],
+          excludeFirstChatMustStart: false,
+        },
+      },
+    },
+    sessionActivity: {
+      sessions: options.sessionActivity ?? {},
+    },
+  } as any
+}
 
 describe('sidebarSelectors', () => {
   describe('buildSessionItems', () => {
@@ -286,10 +362,41 @@ describe('sidebarSelectors', () => {
           hasTab: true,
           hasTitle: true,
           cwd: '/tmp/restored-project',
+          isFallback: true,
         }),
       ])
     })
 
+    it('marks synthesized rows as fallback-only while leaving server-backed rows unmarked', () => {
+      const fallback = createFallbackTab('tab-restored', 'codex-restored', 'Restored Session', '/tmp/restored-project')
+      const items = buildSessionItems(
+        [
+          makeProject([{ sessionId: 'server-session', provider: 'claude', title: 'Server Session' }]),
+        ],
+        [fallback.tab] as any,
+        {
+          layouts: {
+            [fallback.tab.id]: fallback.layout,
+          },
+          activePane: {
+            [fallback.tab.id]: fallback.paneId,
+          },
+          paneTitles: {
+            [fallback.tab.id]: {
+              [fallback.paneId]: fallback.tab.title,
+            },
+          },
+        } as any,
+        emptyTerminals,
+        emptyActivity,
+      )
+
+      expect(items.find((item) => item.sessionId === 'server-session')?.isFallback).toBeUndefined()
+      expect(items.find((item) => item.sessionId === 'codex-restored')).toMatchObject({
+        isFallback: true,
+      })
+    })
+
     it('preserves fallback visibility metadata from tab session metadata so hidden sessions stay filtered', () => {
       const hiddenSessionId = 'codex-hidden'
       const tabs = [
@@ -358,6 +465,176 @@ describe('sidebarSelectors', () => {
     })
   })
 
+  describe('makeSelectSortedSessionItems', () => {
+    it('uses the applied title query to keep only matching fallback rows and rejects ancestor-only matches', () => {
+      const matchingFallback = createFallbackTab('tab-match', 'fallback-match', 'Matching Fallback', '/tmp/local/trycycle')
+      const ancestorFallback = createFallbackTab('tab-ancestor', 'fallback-ancestor', 'Ancestor Fallback', '/tmp/code/local/project')
+      const unrelatedFallback = createFallbackTab('tab-unrelated', 'fallback-unrelated', 'Unrelated Fallback', '/tmp/local/elsewhere')
+      const selectSortedItems = makeSelectSortedSessionItems()
+
+      const items = selectSortedItems(createSelectorState({
+        projects: [
+          {
+            projectPath: '/repo/server',
+            sessions: [{
+              provider: 'claude',
+              sessionId: 'server-newer',
+              projectPath: '/repo/server',
+              lastActivityAt: 3_000,
+              title: 'Newer Server Result',
+            }],
+          },
+          {
+            projectPath: '/repo/code/trycycle',
+            sessions: [{
+              provider: 'claude',
+              sessionId: 'server-leaf',
+              projectPath: '/repo/code/trycycle',
+              cwd: '/repo/code/trycycle/server',
+              lastActivityAt: 2_500,
+              title: 'Routine work',
+            }],
+          },
+        ],
+        tabs: [matchingFallback.tab, ancestorFallback.tab, unrelatedFallback.tab],
+        panes: {
+          layouts: {
+            [matchingFallback.tab.id]: matchingFallback.layout,
+            [ancestorFallback.tab.id]: ancestorFallback.layout,
+            [unrelatedFallback.tab.id]: unrelatedFallback.layout,
+          },
+          activePane: {
+            [matchingFallback.tab.id]: matchingFallback.paneId,
+            [ancestorFallback.tab.id]: ancestorFallback.paneId,
+            [unrelatedFallback.tab.id]: unrelatedFallback.paneId,
+          },
+          paneTitles: {
+            [matchingFallback.tab.id]: { [matchingFallback.paneId]: matchingFallback.tab.title },
+            [ancestorFallback.tab.id]: { [ancestorFallback.paneId]: ancestorFallback.tab.title },
+            [unrelatedFallback.tab.id]: { [unrelatedFallback.paneId]: unrelatedFallback.tab.title },
+          },
+        },
+        sortMode: 'activity',
+        query: 'code',
+        searchTier: 'title',
+        appliedQuery: 'trycycle',
+        appliedSearchTier: 'title',
+      }), [], '')
+
+      expect(items.map((item) => item.sessionId)).toEqual([
+        'server-newer',
+        'server-leaf',
+        'fallback-match',
+      ])
+      expect(items.find((item) => item.sessionId === 'fallback-match')).toMatchObject({
+        isFallback: true,
+      })
+      expect(items.some((item) => item.sessionId === 'fallback-ancestor')).toBe(false)
+      expect(items.some((item) => item.sessionId === 'fallback-unrelated')).toBe(false)
+    })
+
+    it('drops fallback rows entirely for applied deep-search tiers', () => {
+      const matchingFallback = createFallbackTab('tab-match', 'fallback-match', 'Matching Fallback', '/tmp/local/trycycle')
+      const selectSortedItems = makeSelectSortedSessionItems()
+
+      const items = selectSortedItems(createSelectorState({
+        projects: [{
+          projectPath: '/repo/server',
+          sessions: [{
+            provider: 'claude',
+            sessionId: 'server-deep',
+            projectPath: '/repo/server',
+            lastActivityAt: 3_000,
+            title: 'Deep Search Result',
+          }],
+        }],
+        tabs: [matchingFallback.tab],
+        panes: {
+          layouts: {
+            [matchingFallback.tab.id]: matchingFallback.layout,
+          },
+          activePane: {
+            [matchingFallback.tab.id]: matchingFallback.paneId,
+          },
+          paneTitles: {
+            [matchingFallback.tab.id]: { [matchingFallback.paneId]: matchingFallback.tab.title },
+          },
+        },
+        appliedQuery: 'trycycle',
+        appliedSearchTier: 'fullText',
+      }), [], '')
+
+      expect(items.map((item) => item.sessionId)).toEqual(['server-deep'])
+    })
+
+    it('disables tab pinning during applied search in recency-pinned mode while preserving archived-last ordering', () => {
+      const matchingFallback = createFallbackTab('tab-match', 'fallback-match', 'Matching Fallback', '/tmp/local/trycycle')
+      const selectSortedItems = makeSelectSortedSessionItems()
+      const baseOptions = {
+        projects: [
+          {
+            projectPath: '/repo/server',
+            sessions: [{
+              provider: 'claude',
+              sessionId: 'server-newer',
+              projectPath: '/repo/server',
+              lastActivityAt: 3_000,
+              title: 'Newer Server Result',
+            }],
+          },
+          {
+            projectPath: '/repo/archive',
+            sessions: [{
+              provider: 'claude',
+              sessionId: 'server-archived',
+              projectPath: '/repo/archive',
+              lastActivityAt: 4_000,
+              title: 'Archived Result',
+              archived: true,
+            }],
+          },
+        ],
+        tabs: [matchingFallback.tab],
+        panes: {
+          layouts: {
+            [matchingFallback.tab.id]: matchingFallback.layout,
+          },
+          activePane: {
+            [matchingFallback.tab.id]: matchingFallback.paneId,
+          },
+          paneTitles: {
+            [matchingFallback.tab.id]: { [matchingFallback.paneId]: matchingFallback.tab.title },
+          },
+        },
+        sortMode: 'recency-pinned' as const,
+      }
+
+      const searchItems = selectSortedItems(createSelectorState({
+        ...baseOptions,
+        appliedQuery: 'trycycle',
+        appliedSearchTier: 'title',
+      }), [], '')
+
+      expect(searchItems.map((item) => item.sessionId)).toEqual([
+        'server-newer',
+        'fallback-match',
+        'server-archived',
+      ])
+
+      const browseItems = selectSortedItems(createSelectorState({
+        ...baseOptions,
+        query: 'trycycle',
+        searchTier: 'title',
+      }), [], '')
+
+      expect(browseItems.map((item) => item.sessionId)).toEqual([
+        'fallback-match',
+        'server-newer',
+        'server-archived',
+      ])
+    })
+  })
+
   describe('sortSessionItems', () => {
     describe('recency mode', () => {
       it('sorts by timestamp descending', () => {
@@ -478,6 +755,18 @@ describe('sidebarSelectors', () => {
         // Active first (unpinned), then archived (pinned first within archived)
         expect(sorted.map((i) => i.id)).toEqual(['3', '2', '1'])
       })
+
+      it('can disable tab pinning while keeping archived items last', () => {
+        const items = [
+          createSessionItem({ id: '1', timestamp: 3000, hasTab: false }),
+          createSessionItem({ id: '2', timestamp: 1000, hasTab: true }),
+          createSessionItem({ id: '3', timestamp: 4000, hasTab: true, archived: true }),
+        ]
+
+        const sorted = sortSessionItems(items, 'recency-pinned', { disableTabPinning: true })
+
+        expect(sorted.map((i) => i.id)).toEqual(['1', '2', '3'])
+      })
     })
 
     describe('activity mode', () => {
@@ -502,6 +791,18 @@ describe('sidebarSelectors', () => {
 
         expect(sorted.map((i) => i.id)).toEqual(['1', '2'])
       })
+
+      it('can disable tab pinning and use the normal activity comparator for every item', () => {
+        const items = [
+          createSessionItem({ id: '1', timestamp: 3000, hasTab: false }),
+          createSessionItem({ id: '2', timestamp: 1000, hasTab: true }),
+          createSessionItem({ id: '3', timestamp: 4000, hasTab: true, archived: true }),
+        ]
+
+        const sorted = sortSessionItems(items, 'activity', { disableTabPinning: true })
+
+        expect(sorted.map((i) => i.id)).toEqual(['1', '2', '3'])
+      })
     })
 
     describe('project mode', () => {
diff --git a/test/unit/client/store/sessionsSlice.test.ts b/test/unit/client/store/sessionsSlice.test.ts
index 143fa408..43e68cd7 100644
--- a/test/unit/client/store/sessionsSlice.test.ts
+++ b/test/unit/client/store/sessionsSlice.test.ts
@@ -12,7 +12,9 @@ import sessionsReducer, {
   expandAll,
   SessionsState,
   setActiveSessionSurface,
-  setSessionWindowData,
+  commitSessionWindowReplacement,
+  commitSessionWindowVisibleRefresh,
+  setSessionWindowError,
   setSessionWindowLoading,
 } from '@/store/sessionsSlice'
 import type { ProjectGroup } from '@/store/types'
@@ -179,7 +181,7 @@ describe('sessionsSlice', () => {
     it('stores per-surface window data without overwriting another surface', () => {
       let state: SessionsState = sessionsReducer(undefined, setProjects(mockProjects))
       state = sessionsReducer(state, setActiveSessionSurface('sidebar'))
-      state = sessionsReducer(state, setSessionWindowData({
+      state = sessionsReducer(state, commitSessionWindowReplacement({
         surface: 'history',
         projects: [mockProjects[1]],
         totalSessions: 1,
@@ -192,6 +194,157 @@ describe('sessionsSlice', () => {
     })
   })
 
+  describe('explicit sidebar window commits', () => {
+    function createCommittedSidebarState(): SessionsState {
+      return {
+        ...initialState,
+        activeSurface: 'sidebar',
+        projects: [mockProjects[0]],
+        lastLoadedAt: 1700000000000,
+        totalSessions: 2,
+        oldestLoadedTimestamp: 1699999999000,
+        oldestLoadedSessionId: 'claude:session-2',
+        hasMore: false,
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            lastLoadedAt: 1700000000000,
+            totalSessions: 2,
+            oldestLoadedTimestamp: 1699999999000,
+            oldestLoadedSessionId: 'claude:session-2',
+            hasMore: false,
+            query: 'alpha',
+            searchTier: 'title',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+            resultVersion: 7,
+          },
+        },
+      }
+    }
+
+    it('updates requested replacement state immediately without changing the committed visible result version', () => {
+      const state = sessionsReducer(
+        createCommittedSidebarState(),
+        setSessionWindowLoading({
+          surface: 'sidebar',
+          loading: true,
+          loadingKind: 'search',
+          query: 'beta',
+          searchTier: 'fullText',
+        }),
+      )
+
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect(state.windows.sidebar.appliedQuery).toBe('alpha')
+      expect(state.windows.sidebar.appliedSearchTier).toBe('title')
+      expect(state.windows.sidebar.loading).toBe(true)
+      expect(state.windows.sidebar.loadingKind).toBe('search')
+      expect(state.windows.sidebar.resultVersion).toBe(7)
+      expect(state.query).toBeUndefined()
+      expect(state.projects).toEqual([mockProjects[0]])
+    })
+
+    it('commits a replacement by updating requested and applied state together and bumping resultVersion', () => {
+      const replacementProjects = [mockProjects[1]]
+
+      const state = sessionsReducer(
+        createCommittedSidebarState(),
+        commitSessionWindowReplacement({
+          surface: 'sidebar',
+          projects: replacementProjects,
+          totalSessions: 1,
+          oldestLoadedTimestamp: 1700000000500,
+          oldestLoadedSessionId: 'claude:session-3',
+          hasMore: false,
+          query: 'beta',
+          searchTier: 'fullText',
+          deepSearchPending: false,
+        }),
+      )
+
+      expect(state.windows.sidebar.projects).toEqual(replacementProjects)
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect(state.windows.sidebar.appliedQuery).toBe('beta')
+      expect(state.windows.sidebar.appliedSearchTier).toBe('fullText')
+      expect(state.windows.sidebar.loading).toBe(false)
+      expect(state.windows.sidebar.loadingKind).toBeUndefined()
+      expect(state.windows.sidebar.resultVersion).toBe(8)
+      expect(state.projects).toEqual(replacementProjects)
+      expect(state.totalSessions).toBe(1)
+    })
+
+    it('commits a visible refresh without rewriting requested state and can preserve an in-flight replacement load', () => {
+      const replacementLoadingState = sessionsReducer(
+        createCommittedSidebarState(),
+        setSessionWindowLoading({
+          surface: 'sidebar',
+          loading: true,
+          loadingKind: 'search',
+          query: '',
+          searchTier: 'title',
+        }),
+      )
+      const refreshedProjects = [mockProjects[2]]
+
+      const state = sessionsReducer(
+        replacementLoadingState,
+        commitSessionWindowVisibleRefresh({
+          surface: 'sidebar',
+          projects: refreshedProjects,
+          totalSessions: 1,
+          oldestLoadedTimestamp: 1700000001000,
+          oldestLoadedSessionId: 'claude:session-4',
+          hasMore: false,
+          query: 'alpha',
+          searchTier: 'title',
+          preserveLoading: true,
+        }),
+      )
+
+      expect(state.windows.sidebar.projects).toEqual(refreshedProjects)
+      expect(state.windows.sidebar.query).toBe('')
+      expect(state.windows.sidebar.searchTier).toBe('title')
+      expect(state.windows.sidebar.appliedQuery).toBe('alpha')
+      expect(state.windows.sidebar.appliedSearchTier).toBe('title')
+      expect(state.windows.sidebar.loading).toBe(true)
+      expect(state.windows.sidebar.loadingKind).toBe('search')
+      expect(state.windows.sidebar.resultVersion).toBe(8)
+      expect(state.projects).toEqual(refreshedProjects)
+    })
+
+    it('preserves the last applied context and resultVersion when a replacement fails', () => {
+      const loadingState = sessionsReducer(
+        createCommittedSidebarState(),
+        setSessionWindowLoading({
+          surface: 'sidebar',
+          loading: true,
+          loadingKind: 'search',
+          query: 'beta',
+          searchTier: 'fullText',
+        }),
+      )
+
+      const state = sessionsReducer(
+        loadingState,
+        setSessionWindowError({
+          surface: 'sidebar',
+          error: 'Search failed',
+        }),
+      )
+
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect(state.windows.sidebar.appliedQuery).toBe('alpha')
+      expect(state.windows.sidebar.appliedSearchTier).toBe('title')
+      expect(state.windows.sidebar.resultVersion).toBe(7)
+      expect(state.windows.sidebar.error).toBe('Search failed')
+      expect(state.projects).toEqual([mockProjects[0]])
+    })
+  })
+
   describe('clearProjects', () => {
     it('clears all projects', () => {
       const stateWithProjects = {
@@ -619,7 +772,7 @@ describe('sessionsSlice', () => {
   })
 
   describe('deepSearchPending', () => {
-    it('defaults deepSearchPending to false when setSessionWindowData omits it', () => {
+    it('defaults deepSearchPending to false when commitSessionWindowReplacement omits it', () => {
       // Start with a sidebar window that has deepSearchPending: true
       const stateWithPending: SessionsState = {
         ...initialState,
@@ -632,7 +785,7 @@ describe('sessionsSlice', () => {
         },
       }
 
-      const state = sessionsReducer(stateWithPending, setSessionWindowData({
+      const state = sessionsReducer(stateWithPending, commitSessionWindowReplacement({
         surface: 'sidebar',
         projects: mockProjects,
         totalSessions: 3,
@@ -663,4 +816,174 @@ describe('sessionsSlice', () => {
       expect(state.windows.sidebar.deepSearchPending).toBe(false)
     })
   })
+
+  describe('requested vs applied search state', () => {
+    it('setSessionWindowLoading updates the requested query and tier without changing the applied search context', () => {
+      const stateWithAppliedSearch: SessionsState = {
+        ...initialState,
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            query: 'alpha',
+            searchTier: 'title',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+          } as any,
+        },
+      }
+
+      const state = sessionsReducer(stateWithAppliedSearch, setSessionWindowLoading({
+        surface: 'sidebar',
+        loading: true,
+        loadingKind: 'search',
+        query: 'beta',
+        searchTier: 'fullText',
+      }))
+
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect((state.windows.sidebar as any).appliedQuery).toBe('alpha')
+      expect((state.windows.sidebar as any).appliedSearchTier).toBe('title')
+    })
+
+    it('commitSessionWindowReplacement commits requested and applied search fields together with the visible result set', () => {
+      const stateWithAppliedSearch: SessionsState = {
+        ...initialState,
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            query: 'alpha',
+            searchTier: 'title',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+          } as any,
+        },
+      }
+
+      const state = sessionsReducer(stateWithAppliedSearch, commitSessionWindowReplacement({
+        surface: 'sidebar',
+        projects: [mockProjects[1]],
+        totalSessions: 1,
+        hasMore: false,
+        query: 'beta',
+        searchTier: 'fullText',
+      }))
+
+      expect(state.windows.sidebar.projects).toEqual([mockProjects[1]])
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect((state.windows.sidebar as any).appliedQuery).toBe('beta')
+      expect((state.windows.sidebar as any).appliedSearchTier).toBe('fullText')
+      expect(state.projects).toEqual([mockProjects[1]])
+    })
+
+    it('keeps the previous applied search context during a search-to-browse transition until browse data commits', () => {
+      const stateWithAppliedSearch: SessionsState = {
+        ...initialState,
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            query: 'alpha',
+            searchTier: 'title',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+          } as any,
+        },
+      }
+
+      const loadingState = sessionsReducer(stateWithAppliedSearch, setSessionWindowLoading({
+        surface: 'sidebar',
+        loading: true,
+        loadingKind: 'search',
+        query: '',
+        searchTier: 'title',
+      }))
+
+      expect(loadingState.windows.sidebar.query).toBe('')
+      expect(loadingState.windows.sidebar.searchTier).toBe('title')
+      expect((loadingState.windows.sidebar as any).appliedQuery).toBe('alpha')
+      expect((loadingState.windows.sidebar as any).appliedSearchTier).toBe('title')
+
+      const committedState = sessionsReducer(loadingState, commitSessionWindowReplacement({
+        surface: 'sidebar',
+        projects: mockProjects,
+        totalSessions: mockProjects.length,
+        hasMore: true,
+        query: '',
+        searchTier: 'title',
+      }))
+
+      expect((committedState.windows.sidebar as any).appliedQuery).toBe('')
+      expect((committedState.windows.sidebar as any).appliedSearchTier).toBe('title')
+    })
+
+    it('preserves the previous applied search context when a replacement request fails before new data lands', () => {
+      const stateWithReplacementError: SessionsState = {
+        ...initialState,
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            query: 'beta',
+            searchTier: 'fullText',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+            loading: true,
+            loadingKind: 'search',
+          } as any,
+        },
+      }
+
+      const state = sessionsReducer(stateWithReplacementError, setSessionWindowError({
+        surface: 'sidebar',
+        error: 'Search failed',
+      }))
+
+      expect(state.windows.sidebar.query).toBe('beta')
+      expect(state.windows.sidebar.searchTier).toBe('fullText')
+      expect((state.windows.sidebar as any).appliedQuery).toBe('alpha')
+      expect((state.windows.sidebar as any).appliedSearchTier).toBe('title')
+      expect(state.windows.sidebar.error).toBe('Search failed')
+      expect(state.windows.sidebar.loadingKind).toBeUndefined()
+    })
+
+    it('can commit refreshed applied results without overwriting the requested search state or pending loading state', () => {
+      const stateWithPendingBrowseRequest: SessionsState = {
+        ...initialState,
+        activeSurface: 'sidebar',
+        windows: {
+          sidebar: {
+            projects: [mockProjects[0]],
+            query: '',
+            searchTier: 'title',
+            appliedQuery: 'alpha',
+            appliedSearchTier: 'title',
+            loading: true,
+            loadingKind: 'search',
+          } as any,
+        },
+      }
+
+      const state = sessionsReducer(stateWithPendingBrowseRequest, commitSessionWindowVisibleRefresh({
+        surface: 'sidebar',
+        projects: [mockProjects[1]],
+        totalSessions: 1,
+        hasMore: false,
+        query: 'alpha',
+        searchTier: 'title',
+        preserveLoading: true,
+      }))
+
+      expect(state.windows.sidebar.projects).toEqual([mockProjects[1]])
+      expect(state.windows.sidebar.query).toBe('')
+      expect(state.windows.sidebar.searchTier).toBe('title')
+      expect((state.windows.sidebar as any).appliedQuery).toBe('alpha')
+      expect((state.windows.sidebar as any).appliedSearchTier).toBe('title')
+      expect(state.windows.sidebar.loading).toBe(true)
+      expect(state.windows.sidebar.loadingKind).toBe('search')
+    })
+  })
 })
diff --git a/test/unit/client/store/sessionsThunks.test.ts b/test/unit/client/store/sessionsThunks.test.ts
index b87c4d28..f7369a3b 100644
--- a/test/unit/client/store/sessionsThunks.test.ts
+++ b/test/unit/client/store/sessionsThunks.test.ts
@@ -1,7 +1,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { configureStore } from '@reduxjs/toolkit'
 import { enableMapSet } from 'immer'
-import sessionsReducer, { setActiveSessionSurface } from '@/store/sessionsSlice'
+import sessionsReducer, {
+  commitSessionWindowVisibleRefresh,
+  setActiveSessionSurface,
+  setSessionWindowLoading,
+} from '@/store/sessionsSlice'
 import * as sessionsThunks from '@/store/sessionsThunks'
 
 const {
@@ -270,6 +274,237 @@ describe('sessionsThunks', () => {
     expect((store.getState().sessions.windows.sidebar as any).loadingKind).toBeUndefined()
   })
 
+  it('moves requested search state immediately but keeps applied search state on the visible results until each replacement commits', async () => {
+    const replacementSearch = createDeferred<any>()
+    searchSessions.mockReturnValueOnce(replacementSearch.promise)
+
+    const appliedProjects = [{
+      projectPath: '/tmp/project-alpha',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-alpha',
+        projectPath: '/tmp/project-alpha',
+        lastActivityAt: 1_000,
+        title: 'Alpha result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: appliedProjects,
+      lastLoadedAt: 1_000,
+      windows: {
+        sidebar: {
+          projects: appliedProjects,
+          lastLoadedAt: 1_000,
+          query: 'alpha',
+          searchTier: 'title',
+          appliedQuery: 'alpha',
+          appliedSearchTier: 'title',
+        },
+      },
+    })
+
+    const replacementRequest = store.dispatch(fetchSessionWindow({
+      surface: 'sidebar',
+      priority: 'visible',
+      query: 'beta',
+      searchTier: 'title',
+    }) as any)
+
+    let replacementResolved = false
+
+    try {
+      expect((store.getState().sessions.windows.sidebar as any).query).toBe('beta')
+      expect((store.getState().sessions.windows.sidebar as any).searchTier).toBe('title')
+      expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('alpha')
+      expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+
+      replacementSearch.resolve({
+        results: [{
+          provider: 'claude',
+          sessionId: 'session-beta',
+          projectPath: '/tmp/project-beta',
+          title: 'Beta result',
+          matchedIn: 'title',
+          lastActivityAt: 2_000,
+          archived: false,
+        }],
+        tier: 'title',
+        query: 'beta',
+        totalScanned: 1,
+      })
+      replacementResolved = true
+
+      await replacementRequest
+
+      expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('beta')
+      expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+
+      const browseReload = createDeferred<any>()
+      fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseReload.promise)
+
+      const browseRequest = store.dispatch(fetchSessionWindow({
+        surface: 'sidebar',
+        priority: 'visible',
+        query: '',
+        searchTier: 'title',
+      }) as any)
+
+      try {
+        expect((store.getState().sessions.windows.sidebar as any).query).toBe('')
+        expect((store.getState().sessions.windows.sidebar as any).searchTier).toBe('title')
+        expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('beta')
+        expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+      } finally {
+        browseReload.resolve({
+          projects: [],
+          totalSessions: 0,
+          oldestIncludedTimestamp: 0,
+          oldestIncludedSessionId: '',
+          hasMore: false,
+        })
+
+        await browseRequest
+      }
+
+      expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('')
+      expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+    } finally {
+      if (!replacementResolved) {
+        replacementSearch.resolve({
+          results: [],
+          tier: 'title',
+          query: 'beta',
+          totalScanned: 0,
+        })
+        await replacementRequest
+      }
+    }
+  })
+
+  it('preserves the previous applied search context when a replacement request errors before new data lands', async () => {
+    searchSessions.mockRejectedValueOnce(new Error('Search failed'))
+
+    const appliedProjects = [{
+      projectPath: '/tmp/project-alpha',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-alpha',
+        projectPath: '/tmp/project-alpha',
+        lastActivityAt: 1_000,
+        title: 'Alpha result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: appliedProjects,
+      lastLoadedAt: 1_000,
+      windows: {
+        sidebar: {
+          projects: appliedProjects,
+          lastLoadedAt: 1_000,
+          query: 'alpha',
+          searchTier: 'title',
+          appliedQuery: 'alpha',
+          appliedSearchTier: 'title',
+        },
+      },
+    })
+
+    await expect(store.dispatch(fetchSessionWindow({
+      surface: 'sidebar',
+      priority: 'visible',
+      query: 'beta',
+      searchTier: 'fullText',
+    }) as any)).rejects.toThrow('Search failed')
+
+    expect((store.getState().sessions.windows.sidebar as any).query).toBe('beta')
+    expect((store.getState().sessions.windows.sidebar as any).searchTier).toBe('fullText')
+    expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('alpha')
+    expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+    expect((store.getState().sessions.windows.sidebar as any).error).toBe('Search failed')
+  })
+
+  it('preserves the previous applied search context when a replacement request is aborted before new data lands', async () => {
+    const replacementSearch = createDeferred<any>()
+    const browseReload = createDeferred<any>()
+    searchSessions.mockReturnValueOnce(replacementSearch.promise)
+    fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseReload.promise)
+
+    const appliedProjects = [{
+      projectPath: '/tmp/project-alpha',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-alpha',
+        projectPath: '/tmp/project-alpha',
+        lastActivityAt: 1_000,
+        title: 'Alpha result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: appliedProjects,
+      lastLoadedAt: 1_000,
+      windows: {
+        sidebar: {
+          projects: appliedProjects,
+          lastLoadedAt: 1_000,
+          query: 'alpha',
+          searchTier: 'title',
+          appliedQuery: 'alpha',
+          appliedSearchTier: 'title',
+        },
+      },
+    })
+
+    const replacementRequest = store.dispatch(fetchSessionWindow({
+      surface: 'sidebar',
+      priority: 'visible',
+      query: 'beta',
+      searchTier: 'title',
+    }) as any)
+    const replacementSignal = searchSessions.mock.calls[0]?.[0]?.signal as AbortSignal
+
+    const browseRequest = store.dispatch(fetchSessionWindow({
+      surface: 'sidebar',
+      priority: 'visible',
+      query: '',
+      searchTier: 'title',
+    }) as any)
+
+    expect(replacementSignal.aborted).toBe(true)
+    expect((store.getState().sessions.windows.sidebar as any).query).toBe('')
+    expect((store.getState().sessions.windows.sidebar as any).searchTier).toBe('title')
+    expect((store.getState().sessions.windows.sidebar as any).appliedQuery).toBe('alpha')
+    expect((store.getState().sessions.windows.sidebar as any).appliedSearchTier).toBe('title')
+
+    browseReload.resolve({
+      projects: [],
+      totalSessions: 0,
+      oldestIncludedTimestamp: 0,
+      oldestIncludedSessionId: '',
+      hasMore: false,
+    })
+    replacementSearch.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-beta',
+        projectPath: '/tmp/project-beta',
+        title: 'Beta result',
+        lastActivityAt: 2_000,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'beta',
+      totalScanned: 1,
+    })
+
+    await Promise.allSettled([replacementRequest, browseRequest])
+  })
+
   it('appends a later page into the same surface window', async () => {
     fetchSidebarSessionsSnapshot
       .mockResolvedValueOnce({
@@ -408,70 +643,257 @@ describe('sessionsThunks', () => {
     expect((store.getState().sessions.windows.sidebar as any).loadingKind).toBeUndefined()
   })
 
-  it('refreshes the active active-query window silently while reusing its query context', async () => {
-    searchSessions.mockResolvedValue({
+  it('refreshes the visible applied-query window with a two-phase deep search while requested state drifts to browse', async () => {
+    const phase1Deferred = createDeferred<any>()
+    const phase2Deferred = createDeferred<any>()
+    searchSessions
+      .mockReturnValueOnce(phase1Deferred.promise)
+      .mockReturnValueOnce(phase2Deferred.promise)
+
+    const searchProjects = [{
+      projectPath: '/tmp/search-project',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        lastActivityAt: 3_000,
+        title: 'Search result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: searchProjects,
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: searchProjects,
+          lastLoadedAt: 3_000,
+          query: '',
+          searchTier: 'title',
+          appliedQuery: 'needle',
+          appliedSearchTier: 'fullText',
+        },
+      },
+    })
+
+    const request = store.dispatch(refreshActiveSessionWindow() as any)
+
+    expect((store.getState().sessions.windows.sidebar as any).loadingKind).toBe('background')
+    expect(searchSessions).toHaveBeenNthCalledWith(1, {
+      query: 'needle',
+      tier: 'title',
+      signal: expect.any(AbortSignal),
+    })
+
+    phase1Deferred.resolve({
       results: [
         {
           provider: 'claude',
           sessionId: 'session-search',
           projectPath: '/tmp/search-project',
           title: 'Search result',
+          matchedIn: 'title',
           lastActivityAt: 3_000,
           archived: false,
         },
       ],
-      tier: 'fullText',
+      tier: 'title',
       query: 'needle',
       totalScanned: 1,
     })
 
-    const store = createStore()
-    store.dispatch(setActiveSessionSurface('sidebar'))
+    await new Promise((resolve) => setTimeout(resolve, 0))
 
-    await store.dispatch(fetchSessionWindow({
+    expect(searchSessions).toHaveBeenNthCalledWith(2, {
+      query: 'needle',
+      tier: 'fullText',
+      signal: expect.any(AbortSignal),
+    })
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.searchTier).toBe('title')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('fullText')
+    expect(store.getState().sessions.windows.sidebar.deepSearchPending).toBe(true)
+
+    phase2Deferred.resolve({
+      results: [
+        {
+          provider: 'claude',
+          sessionId: 'session-search',
+          projectPath: '/tmp/search-project',
+          title: 'Search result',
+          matchedIn: 'userMessage',
+          lastActivityAt: 3_000,
+          archived: false,
+        },
+      ],
+      tier: 'fullText',
+      query: 'needle',
+      totalScanned: 4,
+    })
+
+    await request
+
+    expect(searchSessions).toHaveBeenCalledTimes(2)
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.searchTier).toBe('title')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('fullText')
+    expect(store.getState().sessions.windows.sidebar.deepSearchPending).toBe(false)
+  })
+
+  it('refreshActiveSessionWindow keeps a pending browse replacement alive during search-to-browse drift and lets it commit afterward', async () => {
+    const searchProjects = [{
+      projectPath: '/tmp/search-project',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        lastActivityAt: 3_000,
+        title: 'Search result',
+      }],
+    }]
+    const browseDeferred = createDeferred<any>()
+    const refreshDeferred = createDeferred<any>()
+    fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseDeferred.promise)
+    searchSessions.mockReturnValueOnce(refreshDeferred.promise)
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: searchProjects,
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: searchProjects,
+          lastLoadedAt: 3_000,
+          query: 'needle',
+          searchTier: 'title',
+          appliedQuery: 'needle',
+          appliedSearchTier: 'title',
+          resultVersion: 4,
+        },
+      },
+    })
+
+    const browseRequest = store.dispatch(fetchSessionWindow({
       surface: 'sidebar',
       priority: 'visible',
-      query: 'needle',
-      searchTier: 'fullText',
+      query: '',
+      searchTier: 'title',
     }) as any)
+    const browseSignal = fetchSidebarSessionsSnapshot.mock.calls[0]?.[0]?.signal as AbortSignal
 
-    searchSessions.mockClear()
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
 
-    const deferred = createDeferred<any>()
-    searchSessions.mockReturnValueOnce(deferred.promise)
+    const refreshRequest = store.dispatch(refreshActiveSessionWindow() as any)
 
-    const request = store.dispatch(refreshActiveSessionWindow() as any)
+    expect(searchSessions).toHaveBeenCalledWith({
+      query: 'needle',
+      tier: 'title',
+      signal: expect.any(AbortSignal),
+    })
+    expect(browseSignal.aborted).toBe(false)
 
-    try {
-      expect((store.getState().sessions.windows.sidebar as any).loadingKind).toBe('background')
-    } finally {
-      deferred.resolve({
-        results: [
-          {
-            provider: 'claude',
-            sessionId: 'session-search',
-            projectPath: '/tmp/search-project',
-            title: 'Search result',
-            lastActivityAt: 3_000,
-            archived: false,
-          },
-        ],
-        tier: 'fullText',
-        query: 'needle',
-        totalScanned: 1,
-      })
+    refreshDeferred.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        title: 'Search result',
+        lastActivityAt: 3_100,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'needle',
+      totalScanned: 1,
+    })
 
-      await request
-    }
+    await refreshRequest
+
+    expect(browseSignal.aborted).toBe(false)
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+
+    browseDeferred.resolve({
+      projects: [],
+      totalSessions: 0,
+      oldestIncludedTimestamp: 0,
+      oldestIncludedSessionId: '',
+      hasMore: false,
+    })
+
+    await browseRequest
+
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('title')
+  })
+
+  it('refreshActiveSessionWindow uses the visible applied query without drift and stays background/silent', async () => {
+    const refreshDeferred = createDeferred<any>()
+    searchSessions.mockReturnValueOnce(refreshDeferred.promise)
 
+    const searchProjects = [{
+      projectPath: '/tmp/search-project',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        lastActivityAt: 3_000,
+        title: 'Search result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: searchProjects,
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: searchProjects,
+          lastLoadedAt: 3_000,
+          query: 'needle',
+          searchTier: 'title',
+          appliedQuery: 'needle',
+          appliedSearchTier: 'title',
+        },
+      },
+    })
+
+    const request = store.dispatch(refreshActiveSessionWindow() as any)
+
+    expect((store.getState().sessions.windows.sidebar as any).loadingKind).toBe('background')
     expect(searchSessions).toHaveBeenCalledWith({
       query: 'needle',
-      tier: 'fullText',
+      tier: 'title',
       signal: expect.any(AbortSignal),
     })
+
+    refreshDeferred.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        title: 'Search result',
+        lastActivityAt: 3_100,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'needle',
+      totalScanned: 1,
+    })
+
+    await request
+
+    expect(store.getState().sessions.windows.sidebar.loadingKind).toBeUndefined()
+    expect(store.getState().sessions.windows.sidebar.query).toBe('needle')
+    expect(store.getState().sessions.windows.sidebar.searchTier).toBe('title')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('title')
   })
 
-  it('marks websocket revalidation as background for both default lists and active queries', async () => {
+  it('marks websocket revalidation as background for both default lists and the visible applied query', async () => {
     const defaultRefresh = createDeferred<any>()
     const searchRefresh = createDeferred<any>()
     fetchSidebarSessionsSnapshot.mockReturnValueOnce(defaultRefresh.promise)
@@ -525,8 +947,10 @@ describe('sessionsThunks', () => {
         sidebar: {
           projects: searchProjects,
           lastLoadedAt: 3_000,
-          query: 'needle',
+          query: '',
           searchTier: 'title',
+          appliedQuery: 'needle',
+          appliedSearchTier: 'title',
         },
       },
     })
@@ -551,6 +975,12 @@ describe('sessionsThunks', () => {
 
       await searchRequest
     }
+
+    expect(searchSessions).toHaveBeenCalledWith({
+      query: 'needle',
+      tier: 'title',
+      signal: expect.any(AbortSignal),
+    })
   })
 
   it('treats websocket recovery without committed sidebar data as an initial blocking load', async () => {
@@ -586,6 +1016,248 @@ describe('sessionsThunks', () => {
     }
   })
 
+  it('silently refreshes the visible applied search during an in-flight search-to-browse transition without overwriting the requested browse state', async () => {
+    const searchProjects = [{
+      projectPath: '/tmp/search-project',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        lastActivityAt: 3_000,
+        title: 'Search result',
+      }],
+    }]
+    const browseDeferred = createDeferred<any>()
+    const invalidationDeferred = createDeferred<any>()
+    fetchSidebarSessionsSnapshot.mockReturnValueOnce(browseDeferred.promise)
+    searchSessions.mockReturnValueOnce(invalidationDeferred.promise)
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: searchProjects,
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: searchProjects,
+          lastLoadedAt: 3_000,
+          query: 'needle',
+          searchTier: 'title',
+          appliedQuery: 'needle',
+          appliedSearchTier: 'title',
+        },
+      },
+    })
+
+    const browseRequest = store.dispatch(fetchSessionWindow({
+      surface: 'sidebar',
+      priority: 'visible',
+      query: '',
+      searchTier: 'title',
+    }) as any)
+    const browseSignal = fetchSidebarSessionsSnapshot.mock.calls[0]?.[0]?.signal as AbortSignal
+
+    expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    expect(browseSignal).toBeDefined()
+    expect(browseSignal.aborted).toBe(false)
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+
+    const invalidationRequest = store.dispatch(queueActiveSessionWindowRefresh() as any)
+
+    expect(searchSessions).toHaveBeenCalledWith({
+      query: 'needle',
+      tier: 'title',
+      signal: expect.any(AbortSignal),
+    })
+
+    invalidationDeferred.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        title: 'Search result',
+        lastActivityAt: 3_100,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'needle',
+      totalScanned: 1,
+    })
+
+    await invalidationRequest
+
+    expect(browseSignal.aborted).toBe(false)
+    expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    expect(store.getState().sessions.windows.sidebar.query).toBe('')
+    expect(store.getState().sessions.windows.sidebar.searchTier).toBe('title')
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('needle')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('title')
+    expect(store.getState().sessions.windows.sidebar.loading).toBe(true)
+
+    browseDeferred.resolve({
+      projects: [],
+      totalSessions: 0,
+      oldestIncludedTimestamp: 0,
+      oldestIncludedSessionId: '',
+      hasMore: false,
+    })
+
+    await browseRequest
+
+    expect(fetchSidebarSessionsSnapshot).toHaveBeenCalledTimes(1)
+    expect(store.getState().sessions.windows.sidebar.appliedQuery).toBe('')
+    expect(store.getState().sessions.windows.sidebar.appliedSearchTier).toBe('title')
+  })
+
+  it('keeps a visible refresh committable when requested state drifts again but the visible result set identity is unchanged', async () => {
+    const refreshDeferred = createDeferred<any>()
+    searchSessions.mockReturnValueOnce(refreshDeferred.promise)
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: [{
+        projectPath: '/tmp/search-project',
+        sessions: [{
+          provider: 'claude',
+          sessionId: 'session-search',
+          projectPath: '/tmp/search-project',
+          lastActivityAt: 3_000,
+          title: 'Search result',
+        }],
+      }],
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: [{
+            projectPath: '/tmp/search-project',
+            sessions: [{
+              provider: 'claude',
+              sessionId: 'session-search',
+              projectPath: '/tmp/search-project',
+              lastActivityAt: 3_000,
+              title: 'Search result',
+            }],
+          }],
+          lastLoadedAt: 3_000,
+          query: 'beta',
+          searchTier: 'title',
+          appliedQuery: 'alpha',
+          appliedSearchTier: 'title',
+          loading: true,
+          loadingKind: 'search',
+          resultVersion: 11,
+        },
+      },
+    })
+
+    const refreshRequest = store.dispatch(queueActiveSessionWindowRefresh() as any)
+
+    store.dispatch(setSessionWindowLoading({
+      surface: 'sidebar',
+      loading: true,
+      loadingKind: 'search',
+      query: '',
+      searchTier: 'title',
+    }))
+
+    refreshDeferred.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        title: 'Search result refreshed',
+        lastActivityAt: 3_500,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'alpha',
+      totalScanned: 1,
+    })
+
+    await refreshRequest
+
+    const windowState = store.getState().sessions.windows.sidebar
+    expect(windowState.query).toBe('')
+    expect(windowState.appliedQuery).toBe('alpha')
+    expect(windowState.projects[0]?.sessions[0]?.title).toBe('Search result refreshed')
+    expect(windowState.resultVersion).toBe(12)
+  })
+
+  it('drops a stale visible refresh once a newer committed resultVersion replaces the visible set', async () => {
+    const staleRefresh = createDeferred<any>()
+    searchSessions.mockReturnValueOnce(staleRefresh.promise)
+
+    const initialProjects = [{
+      projectPath: '/tmp/search-project',
+      sessions: [{
+        provider: 'claude',
+        sessionId: 'session-search',
+        projectPath: '/tmp/search-project',
+        lastActivityAt: 3_000,
+        title: 'Initial search result',
+      }],
+    }]
+
+    const store = createStoreWithSessions({
+      activeSurface: 'sidebar',
+      projects: initialProjects,
+      lastLoadedAt: 3_000,
+      windows: {
+        sidebar: {
+          projects: initialProjects,
+          lastLoadedAt: 3_000,
+          query: 'alpha',
+          searchTier: 'title',
+          appliedQuery: 'alpha',
+          appliedSearchTier: 'title',
+          resultVersion: 2,
+        },
+      },
+    })
+
+    const refreshRequest = store.dispatch(queueActiveSessionWindowRefresh() as any)
+
+    store.dispatch(commitSessionWindowVisibleRefresh({
+      surface: 'sidebar',
+      projects: [{
+        projectPath: '/tmp/search-project',
+        sessions: [{
+          provider: 'claude',
+          sessionId: 'session-newer',
+          projectPath: '/tmp/search-project',
+          lastActivityAt: 4_000,
+          title: 'Newer committed result',
+        }],
+      }],
+      totalSessions: 1,
+      oldestLoadedTimestamp: 4_000,
+      oldestLoadedSessionId: 'claude:session-newer',
+      hasMore: false,
+      query: 'alpha',
+      searchTier: 'title',
+    }))
+
+    staleRefresh.resolve({
+      results: [{
+        provider: 'claude',
+        sessionId: 'session-stale',
+        projectPath: '/tmp/search-project',
+        title: 'Stale refresh result',
+        lastActivityAt: 3_100,
+        archived: false,
+      }],
+      tier: 'title',
+      query: 'alpha',
+      totalScanned: 1,
+    })
+
+    await refreshRequest
+
+    const windowState = store.getState().sessions.windows.sidebar
+    expect(windowState.projects[0]?.sessions[0]?.title).toBe('Newer committed result')
+    expect(windowState.resultVersion).toBe(3)
+  })
+
   it('coalesces repeated invalidations into one in-flight fetch plus one trailing refresh', async () => {
     const firstFetch = createDeferred<any>()
     fetchSidebarSessionsSnapshot
diff --git a/test/unit/client/store/turnCompletionSlice.test.ts b/test/unit/client/store/turnCompletionSlice.test.ts
index dcc5c6fe..d12f2c76 100644
--- a/test/unit/client/store/turnCompletionSlice.test.ts
+++ b/test/unit/client/store/turnCompletionSlice.test.ts
@@ -150,6 +150,10 @@ describe('turnCompletionSlice', () => {
             activePane: { 'tab-1': 'pane-1' },
             paneTitles: {},
             paneTitleSetByUser: {},
+            renameRequestTabId: null,
+            renameRequestPaneId: null,
+            zoomedPane: {},
+            refreshRequestsByPane: {},
           },
           settings: { settings: defaultSettings, loaded: true },
           turnCompletion: {
@@ -186,7 +190,8 @@ describe('turnCompletionSlice', () => {
 
     it('closeTab clears tab and all pane attention entries', async () => {
       const store = createFullStore()
-      await store.dispatch(closeTab('tab-1'))
+      const result = await store.dispatch(closeTab('tab-1'))
+      expect(result.type).toBe(closeTab.fulfilled.type)
       expect(store.getState().turnCompletion.attentionByTab['tab-1']).toBeUndefined()
       expect(store.getState().turnCompletion.attentionByPane['pane-1']).toBeUndefined()
       expect(store.getState().turnCompletion.attentionByPane['pane-2']).toBeUndefined()
diff --git a/test/unit/lib/terminal-restore.test.ts b/test/unit/lib/terminal-restore.test.ts
index d4893869..a531d716 100644
--- a/test/unit/lib/terminal-restore.test.ts
+++ b/test/unit/lib/terminal-restore.test.ts
@@ -22,4 +22,22 @@ describe('terminal-restore', () => {
     // Consumed — second call returns false
     expect(consumeTerminalRestoreRequestId('new-reconnect-id')).toBe(false)
   })
+
+  it('registering new IDs after clearDeadTerminals enables restore bypass', async () => {
+    const { consumeTerminalRestoreRequestId, addTerminalRestoreRequestId } = await import('@/lib/terminal-restore')
+    // Simulate the flow: clearDeadTerminals generates new IDs,
+    // then App.tsx registers them with addTerminalRestoreRequestId
+    const newIds = ['new-id-1', 'new-id-2', 'new-id-3']
+    for (const id of newIds) {
+      addTerminalRestoreRequestId(id)
+    }
+    // All new IDs should be consumable (enabling restore: true)
+    for (const id of newIds) {
+      expect(consumeTerminalRestoreRequestId(id)).toBe(true)
+    }
+    // Already consumed
+    for (const id of newIds) {
+      expect(consumeTerminalRestoreRequestId(id)).toBe(false)
+    }
+  })
 })
diff --git a/test/unit/server/mcp/freshell-tool.test.ts b/test/unit/server/mcp/freshell-tool.test.ts
index 14d192ad..cf3487be 100644
--- a/test/unit/server/mcp/freshell-tool.test.ts
+++ b/test/unit/server/mcp/freshell-tool.test.ts
@@ -1177,11 +1177,23 @@ describe('executeAction -- parameter validation', () => {
     expect(mockClient.post).toHaveBeenCalledWith('/api/tabs', expect.objectContaining({ name: 'Work', mode: 'claude' }))
   })
 
-  it('action without params schema (tmux alias) skips validation', async () => {
-    mockClient.post.mockResolvedValue({ id: 't1' })
+  it('tmux alias validates params against the resolved action', async () => {
     const result = await executeAction('new-window', { unknownParam: 'value' })
-    // new-window is a tmux alias, not in ACTION_PARAMS directly, so no validation
+    expect(result).toHaveProperty('error')
+    expect(result.error).toContain('unknownParam')
+  })
+
+  it('tmux alias with valid params routes through', async () => {
+    mockClient.post.mockResolvedValue({ id: 't1' })
+    const result = await executeAction('new-window', { name: 'Work', mode: 'claude' })
     expect(result).not.toHaveProperty('error')
+    expect(mockClient.post).toHaveBeenCalledWith('/api/tabs', expect.objectContaining({ name: 'Work', mode: 'claude' }))
+  })
+
+  it('tmux alias surfaces common confusion hints', async () => {
+    const result = await executeAction('new-window', { url: 'https://example.com' })
+    expect(result).toHaveProperty('error')
+    expect(result.error).toContain('open-browser')
   })
 
   it('empty params on paramless action succeeds', async () => {
diff --git a/test/unit/server/session-directory/service.test.ts b/test/unit/server/session-directory/service.test.ts
index 47ba2b0d..1e88c39c 100644
--- a/test/unit/server/session-directory/service.test.ts
+++ b/test/unit/server/session-directory/service.test.ts
@@ -133,6 +133,139 @@ describe('querySessionDirectory', () => {
     expect(page.items[2]?.snippet?.toLowerCase()).toContain('deploy')
   })
 
+  it('matches a title-tier query against the indexed project-path leaf and rejects ancestor-only path text', async () => {
+    const page = await querySessionDirectory({
+      projects: [
+        makeProject('/home/user/code/trycycle', [
+          makeSession({
+            sessionId: 'session-leaf',
+            projectPath: '/home/user/code/trycycle',
+            cwd: '/home/user/code/trycycle/server',
+            lastActivityAt: 900,
+            title: 'Routine work',
+            summary: 'Metadata without the query',
+            firstUserMessage: 'Still no query here',
+          }),
+        ]),
+      ],
+      terminalMeta: [],
+      query: {
+        priority: 'visible',
+        query: 'trycycle',
+        tier: 'title',
+      },
+    })
+
+    expect(page.items).toHaveLength(1)
+    expect(page.items[0]).toMatchObject({
+      sessionId: 'session-leaf',
+      matchedIn: 'title',
+      snippet: 'trycycle',
+    })
+
+    const ancestorOnlyPage = await querySessionDirectory({
+      projects: [
+        makeProject('/home/user/code/trycycle', [
+          makeSession({
+            sessionId: 'session-leaf',
+            projectPath: '/home/user/code/trycycle',
+            cwd: '/home/user/code/trycycle/server',
+            lastActivityAt: 900,
+            title: 'Routine work',
+            summary: 'Metadata without the query',
+            firstUserMessage: 'Still no query here',
+          }),
+        ]),
+      ],
+      terminalMeta: [],
+      query: {
+        priority: 'visible',
+        query: 'code',
+        tier: 'title',
+      },
+    })
+
+    expect(ancestorOnlyPage.items).toHaveLength(0)
+  })
+
+  it('keeps ordering and focused snippets for title-tier metadata and directory matches without providers', async () => {
+    const page = await querySessionDirectory({
+      projects: [
+        makeProject('/repo/title', [
+          makeSession({
+            sessionId: 'session-title',
+            projectPath: '/repo/title',
+            lastActivityAt: 1_300,
+            title: 'Trycycle rollout notes',
+          }),
+        ]),
+        makeProject('/repo/team/trycycle', [
+          makeSession({
+            sessionId: 'session-leaf',
+            projectPath: '/repo/team/trycycle',
+            cwd: '/repo/team/trycycle/server',
+            lastActivityAt: 1_250,
+            title: 'Routine work',
+          }),
+        ]),
+        makeProject('/repo/summary', [
+          makeSession({
+            sessionId: 'session-summary',
+            projectPath: '/repo/summary',
+            lastActivityAt: 1_100,
+            title: 'Routine work',
+            summary: 'This summary explains how the trycycle migration should roll out in production without surprises.',
+          }),
+        ]),
+        makeProject('/repo/first-user', [
+          makeSession({
+            sessionId: 'session-first-user',
+            projectPath: '/repo/first-user',
+            lastActivityAt: 1_000,
+            title: 'Routine work',
+            firstUserMessage: 'Please double-check the trycycle migration before shipping.',
+          }),
+        ]),
+        makeProject('/repo/archive/trycycle', [
+          makeSession({
+            sessionId: 'session-archived',
+            projectPath: '/repo/archive/trycycle',
+            lastActivityAt: 1_400,
+            archived: true,
+            title: 'Archived notes',
+          }),
+        ]),
+      ],
+      terminalMeta: [],
+      query: {
+        priority: 'visible',
+        query: 'trycycle',
+        tier: 'title',
+      },
+    })
+
+    expect(page.items.map((item) => item.sessionId)).toEqual([
+      'session-title',
+      'session-leaf',
+      'session-summary',
+      'session-first-user',
+      'session-archived',
+    ])
+    expect(page.items.map((item) => item.matchedIn)).toEqual([
+      'title',
+      'title',
+      'summary',
+      'firstUserMessage',
+      'title',
+    ])
+    expect(page.items.every((item) => (item.snippet?.length ?? 0) <= 140)).toBe(true)
+    expect(page.items[0]?.snippet?.toLowerCase()).toContain('trycycle')
+    expect(page.items[1]?.snippet).toBe('trycycle')
+    expect(page.items[2]?.snippet?.toLowerCase()).toContain('trycycle')
+    expect(page.items[3]?.snippet?.toLowerCase()).toContain('trycycle')
+    expect(page.items[4]?.snippet).toBe('trycycle')
+  })
+
   it('bounds page size and provides a deterministic cursor window', async () => {
     const firstPage = await querySessionDirectory({
       projects,
diff --git a/test/unit/server/session-queue.test.ts b/test/unit/server/session-queue.test.ts
index bf6635b8..638f4741 100644
--- a/test/unit/server/session-queue.test.ts
+++ b/test/unit/server/session-queue.test.ts
@@ -5,7 +5,7 @@ import os from 'os'
 import { SessionRepairQueue, Priority } from '../../../server/session-scanner/queue.js'
 import { createSessionScanner } from '../../../server/session-scanner/scanner.js'
 import { SessionCache } from '../../../server/session-scanner/cache.js'
-import type { SessionScanResult, SessionRepairResult } from '../../../server/session-scanner/types.js'
+import type { SessionScanResult, SessionRepairResult, SessionRepairOptions } from '../../../server/session-scanner/types.js'
 
 const FIXTURES_DIR = path.join(__dirname, '../../fixtures/sessions')
 
@@ -349,6 +349,182 @@ describe('SessionRepairQueue', () => {
       await localQueue.stop()
     })
 
+    it('does not repair healthy sessions with resume issues during disk scans', async () => {
+      const scanResult: SessionScanResult = {
+        sessionId: 'resume-issue',
+        filePath: '/tmp/resume-issue.jsonl',
+        status: 'healthy',
+        chainDepth: 5,
+        orphanCount: 0,
+        fileSize: 500,
+        messageCount: 5,
+        resumeIssue: 'inline_stop_hook_progress',
+      }
+
+      const scanner = {
+        scan: vi.fn().mockResolvedValue(scanResult),
+        repair: vi.fn(),
+        scanBatch: vi.fn(),
+      }
+
+      const localCache = new SessionCache(path.join(tempDir, 'cache-disk.json'))
+      const localQueue = new SessionRepairQueue(scanner as any, localCache)
+
+      localQueue.enqueue([
+        { sessionId: 'resume-issue', filePath: '/tmp/resume-issue.jsonl', priority: 'disk' },
+      ])
+
+      localQueue.start()
+      const result = await localQueue.waitFor('resume-issue', 5000)
+
+      expect(result.status).toBe('healthy')
+      expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+      expect(scanner.repair).not.toHaveBeenCalled()
+
+      await localQueue.stop()
+    })
+
+    it('repairs healthy sessions with resume issues during active scans', async () => {
+      const scanResult: SessionScanResult = {
+        sessionId: 'resume-issue',
+        filePath: '/tmp/resume-issue.jsonl',
+        status: 'healthy',
+        chainDepth: 5,
+        orphanCount: 0,
+        fileSize: 500,
+        messageCount: 5,
+        resumeIssue: 'inline_stop_hook_progress',
+      }
+
+      const repairedScanResult: SessionScanResult = {
+        ...scanResult,
+        resumeIssue: undefined,
+      }
+
+      const scanner = {
+        scan: vi.fn()
+          .mockResolvedValueOnce(scanResult)
+          .mockResolvedValueOnce(repairedScanResult),
+        repair: vi.fn().mockResolvedValue({
+          sessionId: 'resume-issue',
+          status: 'repaired',
+          orphansFixed: 0,
+          resumeIssuesFixed: 1,
+          newChainDepth: 5,
+        }),
+        scanBatch: vi.fn(),
+      }
+
+      const localCache = new SessionCache(path.join(tempDir, 'cache-active.json'))
+      const localQueue = new SessionRepairQueue(scanner as any, localCache)
+
+      localQueue.enqueue([
+        { sessionId: 'resume-issue', filePath: '/tmp/resume-issue.jsonl', priority: 'active' },
+      ])
+
+      localQueue.start()
+      const result = await localQueue.waitFor('resume-issue', 5000)
+
+      expect(result.status).toBe('healthy')
+      expect(result.resumeIssue).toBeUndefined()
+      expect(scanner.repair).toHaveBeenCalledWith('/tmp/resume-issue.jsonl', { includeResumeIssues: true })
+
+      await localQueue.stop()
+    })
+
+    it('bypasses cache for active priority when cached result has resume issue', async () => {
+      const cachedResult: SessionScanResult = {
+        sessionId: 'cached-resume-issue',
+        filePath: path.join(tempDir, 'cached-resume.jsonl'),
+        status: 'healthy',
+        chainDepth: 5,
+        orphanCount: 0,
+        fileSize: 500,
+        messageCount: 5,
+        resumeIssue: 'inline_stop_hook_progress',
+      }
+
+      // Create a real file so cache.set stat() works
+      await fs.writeFile(path.join(tempDir, 'cached-resume.jsonl'), '{}')
+
+      const repairedScanResult: SessionScanResult = {
+        ...cachedResult,
+        resumeIssue: undefined,
+      }
+
+      const scanner = {
+        scan: vi.fn()
+          .mockResolvedValueOnce(cachedResult)
+          .mockResolvedValueOnce(repairedScanResult),
+        repair: vi.fn().mockResolvedValue({
+          sessionId: 'cached-resume-issue',
+          status: 'repaired',
+          orphansFixed: 0,
+          resumeIssuesFixed: 1,
+          newChainDepth: 5,
+        }),
+        scanBatch: vi.fn(),
+      }
+
+      const localCache = new SessionCache(path.join(tempDir, 'cache-bypass.json'))
+      // Seed cache with the resume-issue result
+      await localCache.set(path.join(tempDir, 'cached-resume.jsonl'), cachedResult)
+
+      const localQueue = new SessionRepairQueue(scanner as any, localCache)
+      localQueue.enqueue([
+        { sessionId: 'cached-resume-issue', filePath: path.join(tempDir, 'cached-resume.jsonl'), priority: 'active' },
+      ])
+
+      localQueue.start()
+      const result = await localQueue.waitFor('cached-resume-issue', 5000)
+
+      expect(result.resumeIssue).toBeUndefined()
+      expect(scanner.repair).toHaveBeenCalledWith(
+        path.join(tempDir, 'cached-resume.jsonl'),
+        { includeResumeIssues: true },
+      )
+
+      await localQueue.stop()
+    })
+
+    it('uses cached resume-issue result for disk priority without repair', async () => {
+      const cachedResult: SessionScanResult = {
+        sessionId: 'cached-disk-resume',
+        filePath: path.join(tempDir, 'cached-disk.jsonl'),
+        status: 'healthy',
+        chainDepth: 5,
+        orphanCount: 0,
+        fileSize: 500,
+        messageCount: 5,
+        resumeIssue: 'inline_stop_hook_progress',
+      }
+
+      await fs.writeFile(path.join(tempDir, 'cached-disk.jsonl'), '{}')
+
+      const scanner = {
+        scan: vi.fn(),
+        repair: vi.fn(),
+        scanBatch: vi.fn(),
+      }
+
+      const localCache = new SessionCache(path.join(tempDir, 'cache-disk-reuse.json'))
+      await localCache.set(path.join(tempDir, 'cached-disk.jsonl'), cachedResult)
+
+      const localQueue = new SessionRepairQueue(scanner as any, localCache)
+      localQueue.enqueue([
+        { sessionId: 'cached-disk-resume', filePath: path.join(tempDir, 'cached-disk.jsonl'), priority: 'disk' },
+      ])
+
+      localQueue.start()
+      const result = await localQueue.waitFor('cached-disk-resume', 5000)
+
+      expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+      expect(scanner.scan).not.toHaveBeenCalled()
+      expect(scanner.repair).not.toHaveBeenCalled()
+
+      await localQueue.stop()
+    })
+
     it('auto-starts when new items are enqueued after drain', async () => {
       const scanned: SessionScanResult[] = []
       queue.on('scanned', (result) => scanned.push(result))
diff --git a/test/unit/server/session-scanner.test.ts b/test/unit/server/session-scanner.test.ts
index 9c0aacbc..630581e0 100644
--- a/test/unit/server/session-scanner.test.ts
+++ b/test/unit/server/session-scanner.test.ts
@@ -101,6 +101,29 @@ describe('SessionScanner', () => {
       const stat = await fs.stat(path.join(FIXTURES_DIR, 'healthy.jsonl'))
       expect(result.fileSize).toBe(stat.size)
     })
+
+    it('flags inline stop-hook progress on the active chain as a resume issue', async () => {
+      const result = await scanner.scan(path.join(FIXTURES_DIR, 'inline-stop-hook-progress.jsonl'))
+
+      expect(result.status).toBe('healthy')
+      expect(result.orphanCount).toBe(0)
+      expect(result.resumeIssue).toBe('inline_stop_hook_progress')
+    })
+
+    it('does not flag sibling stop-hook progress that is off the active chain', async () => {
+      const result = await scanner.scan(path.join(FIXTURES_DIR, 'sibling-stop-hook-progress.jsonl'))
+
+      expect(result.status).toBe('healthy')
+      expect(result.orphanCount).toBe(0)
+      expect(result.resumeIssue).toBeUndefined()
+    })
+
+    it('does not flag resume issue for files without stop-hook progress', async () => {
+      const result = await scanner.scan(path.join(FIXTURES_DIR, 'healthy.jsonl'))
+
+      expect(result.status).toBe('healthy')
+      expect(result.resumeIssue).toBeUndefined()
+    })
   })
 
   describe('repair()', () => {
@@ -223,6 +246,115 @@ describe('SessionScanner', () => {
       expect(scanAfter.chainDepth).toBe(21)
     })
 
+    it('rewrites stop_hook_summary parentUuid to bypass inline stop-hook progress when enabled', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+      const result = await scanner.repair(testFile, { includeResumeIssues: true })
+
+      expect(result.status).toBe('repaired')
+      expect(result.resumeIssuesFixed).toBe(1)
+      expect(result.orphansFixed).toBe(0)
+
+      // Verify the file is now clean (no resume issue)
+      const scanAfter = await scanner.scan(testFile)
+      expect(scanAfter.status).toBe('healthy')
+      expect(scanAfter.resumeIssue).toBeUndefined()
+    })
+
+    it('does not rewrite inline-progress sessions during default repair (no options)', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+      const result = await scanner.repair(testFile)
+
+      expect(result.status).toBe('already_healthy')
+      expect(result.resumeIssuesFixed).toBe(0)
+      expect(result.orphansFixed).toBe(0)
+
+      // Resume issue should still be present
+      const scanAfter = await scanner.scan(testFile)
+      expect(scanAfter.resumeIssue).toBe('inline_stop_hook_progress')
+    })
+
+    it('repair is idempotent for inline stop-hook progress', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+      const result1 = await scanner.repair(testFile, { includeResumeIssues: true })
+      expect(result1.status).toBe('repaired')
+      expect(result1.resumeIssuesFixed).toBe(1)
+
+      const result2 = await scanner.repair(testFile, { includeResumeIssues: true })
+      expect(result2.status).toBe('already_healthy')
+      expect(result2.resumeIssuesFixed).toBe(0)
+    })
+
+    it('preserves all fields except stop_hook_summary.parentUuid during inline progress repair', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+      const linesBefore = (await fs.readFile(testFile, 'utf8')).split('\n').filter(Boolean)
+
+      await scanner.repair(testFile, { includeResumeIssues: true })
+
+      const linesAfter = (await fs.readFile(testFile, 'utf8')).split('\n').filter(Boolean)
+      expect(linesAfter.length).toBe(linesBefore.length)
+
+      for (let i = 0; i < linesBefore.length; i++) {
+        const before = JSON.parse(linesBefore[i])
+        const after = JSON.parse(linesAfter[i])
+
+        // uuid, type, and all non-parentUuid fields must be preserved
+        expect(after.uuid).toBe(before.uuid)
+        expect(after.type).toBe(before.type)
+
+        // Only the stop_hook_summary line should have a changed parentUuid
+        if (before.uuid === 's-004') {
+          // stop_hook_summary was re-parented from progress (p-003) to assistant (a-002)
+          expect(before.parentUuid).toBe('p-003')
+          expect(after.parentUuid).toBe('a-002')
+        } else {
+          expect(after.parentUuid).toBe(before.parentUuid)
+        }
+      }
+    })
+
+    it('creates backup before inline progress repair', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+      const originalContent = await fs.readFile(testFile, 'utf8')
+
+      const result = await scanner.repair(testFile, { includeResumeIssues: true })
+
+      expect(result.backupPath).toBeDefined()
+      expect(result.backupPath).toMatch(/\.backup-\d+$/)
+
+      const backupContent = await fs.readFile(result.backupPath!, 'utf8')
+      expect(backupContent).toBe(originalContent)
+    })
+
+    it('does not create backup when inline progress repair is not enabled', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+      const result = await scanner.repair(testFile)
+
+      expect(result.status).toBe('already_healthy')
+      expect(result.backupPath).toBeUndefined()
+    })
+
+    it('leaves progress record in file as side leaf after repair', async () => {
+      const testFile = await copyFixture('inline-stop-hook-progress.jsonl')
+
+      await scanner.repair(testFile, { includeResumeIssues: true })
+
+      const content = await fs.readFile(testFile, 'utf8')
+      const lines = content.split('\n').filter(Boolean)
+      const progressLine = lines.find(l => {
+        const obj = JSON.parse(l)
+        return obj.uuid === 'p-003'
+      })
+      expect(progressLine).toBeDefined()
+      // Progress record should still be parented to assistant
+      const progressObj = JSON.parse(progressLine!)
+      expect(progressObj.parentUuid).toBe('a-002')
+      expect(progressObj.type).toBe('progress')
+    })
+
     it('repairs real-world corrupted session from production', async () => {
       // This is a real corrupted session from freshell development
       // Session b7936c10-4935-441c-837c-c1f33cafec2d had a progress message
diff --git a/test/unit/server/updater/version-checker.test.ts b/test/unit/server/updater/version-checker.test.ts
index 140acf33..c61b23db 100644
--- a/test/unit/server/updater/version-checker.test.ts
+++ b/test/unit/server/updater/version-checker.test.ts
@@ -229,6 +229,93 @@ describe('version-checker', () => {
     })
   })
 
+  describe('createCachedUpdateChecker', () => {
+    it('calls the underlying checker on first invocation', async () => {
+      const { createCachedUpdateChecker } = await import('../../../../server/updater/version-checker.js')
+      const inner = vi.fn().mockResolvedValue({
+        updateAvailable: false,
+        currentVersion: '1.0.0',
+        latestVersion: '1.0.0',
+        releaseUrl: null,
+        error: null,
+      })
+
+      const cached = createCachedUpdateChecker(inner, 60_000)
+      const result = await cached('1.0.0')
+
+      expect(inner).toHaveBeenCalledTimes(1)
+      expect(result.currentVersion).toBe('1.0.0')
+    })
+
+    it('returns cached result on second call within TTL', async () => {
+      const { createCachedUpdateChecker } = await import('../../../../server/updater/version-checker.js')
+      const inner = vi.fn().mockResolvedValue({
+        updateAvailable: true,
+        currentVersion: '1.0.0',
+        latestVersion: '2.0.0',
+        releaseUrl: 'https://example.com',
+        error: null,
+      })
+
+      const cached = createCachedUpdateChecker(inner, 60_000)
+      await cached('1.0.0')
+      const result = await cached('1.0.0')
+
+      expect(inner).toHaveBeenCalledTimes(1)
+      expect(result.updateAvailable).toBe(true)
+    })
+
+    it('re-fetches after TTL expires', async () => {
+      const { createCachedUpdateChecker } = await import('../../../../server/updater/version-checker.js')
+      vi.useFakeTimers()
+
+      const inner = vi.fn().mockResolvedValue({
+        updateAvailable: false,
+        currentVersion: '1.0.0',
+        latestVersion: '1.0.0',
+        releaseUrl: null,
+        error: null,
+      })
+
+      const cached = createCachedUpdateChecker(inner, 5_000)
+      await cached('1.0.0')
+      expect(inner).toHaveBeenCalledTimes(1)
+
+      vi.advanceTimersByTime(6_000)
+      await cached('1.0.0')
+      expect(inner).toHaveBeenCalledTimes(2)
+
+      vi.useRealTimers()
+    })
+
+    it('does not cache error responses', async () => {
+      const { createCachedUpdateChecker } = await import('../../../../server/updater/version-checker.js')
+      const inner = vi.fn()
+        .mockResolvedValueOnce({
+          updateAvailable: false,
+          currentVersion: '1.0.0',
+          latestVersion: null,
+          releaseUrl: null,
+          error: 'GitHub API returned 500',
+        })
+        .mockResolvedValueOnce({
+          updateAvailable: false,
+          currentVersion: '1.0.0',
+          latestVersion: '1.0.0',
+          releaseUrl: null,
+          error: null,
+        })
+
+      const cached = createCachedUpdateChecker(inner, 60_000)
+      const first = await cached('1.0.0')
+      expect(first.error).toBe('GitHub API returned 500')
+
+      const second = await cached('1.0.0')
+      expect(inner).toHaveBeenCalledTimes(2)
+      expect(second.error).toBeNull()
+    })
+  })
+
   describe('GitHubReleaseSchema', () => {
     it('validates a correct release object', () => {
       const validRelease = {
diff --git a/test/unit/shared/session-title-search.test.ts b/test/unit/shared/session-title-search.test.ts
new file mode 100644
index 00000000..ca45e8e7
--- /dev/null
+++ b/test/unit/shared/session-title-search.test.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest'
+import { getLeafDirectoryName, matchTitleTierMetadata } from '../../../shared/session-title-search.js'
+
+describe('getLeafDirectoryName', () => {
+  it('extracts a POSIX leaf directory name and trims trailing separators', () => {
+    expect(getLeafDirectoryName('/home/user/code/trycycle')).toBe('trycycle')
+    expect(getLeafDirectoryName('/home/user/code/trycycle/')).toBe('trycycle')
+  })
+
+  it('extracts a Windows leaf directory name and trims trailing separators', () => {
+    expect(getLeafDirectoryName('C:\\Users\\me\\code\\trycycle')).toBe('trycycle')
+    expect(getLeafDirectoryName('C:\\Users\\me\\code\\trycycle\\')).toBe('trycycle')
+  })
+})
+
+describe('matchTitleTierMetadata', () => {
+  it('matches title metadata before directory, summary, and first-user-message metadata', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Trycycle planning notes',
+      projectPath: '/repo/trycycle',
+      cwd: '/repo/work/trycycle',
+      summary: 'Summary mentions trycycle too',
+      firstUserMessage: 'Need help with trycycle rollout',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'title',
+      matchedValue: 'Trycycle planning notes',
+    })
+  })
+
+  it('matches the indexed project-path leaf before a deeper cwd leaf and later metadata fields', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Routine work',
+      projectPath: '/repo/trycycle',
+      cwd: '/repo/trycycle/server',
+      summary: 'Summary mentions trycycle too',
+      firstUserMessage: 'Need help with trycycle rollout',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'title',
+      matchedValue: 'trycycle',
+    })
+  })
+
+  it('matches a distinct cwd leaf before summary and first-user-message metadata', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Routine work',
+      projectPath: '/repo/alpha',
+      cwd: '/repo/alpha/trycycle',
+      summary: 'Summary mentions trycycle too',
+      firstUserMessage: 'Need help with trycycle rollout',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'title',
+      matchedValue: 'trycycle',
+    })
+  })
+
+  it('matches summary metadata before first-user-message metadata', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Routine work',
+      summary: 'Summary mentions trycycle first',
+      firstUserMessage: 'Trycycle also appears here',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'summary',
+      matchedValue: 'Summary mentions trycycle first',
+    })
+  })
+
+  it('matches a cwd leaf for fallback-only metadata when no project path is available', () => {
+    expect(matchTitleTierMetadata({
+      cwd: '/repo/trycycle',
+      firstUserMessage: 'No other metadata matches',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'title',
+      matchedValue: 'trycycle',
+    })
+  })
+
+  it('returns a non-null metadata match for directory-only metadata', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Routine work',
+      projectPath: '/repo/trycycle',
+    }, 'trycycle')).toEqual({
+      matchedIn: 'title',
+      matchedValue: 'trycycle',
+    })
+  })
+
+  it('does not match ancestor-only path segments when no other metadata contains the query', () => {
+    expect(matchTitleTierMetadata({
+      title: 'Routine work',
+      projectPath: '/home/user/code/trycycle',
+      cwd: '/home/user/code/trycycle/server',
+      summary: 'Summary without the search term',
+      firstUserMessage: 'No match here either',
+    }, 'code')).toBeNull()
+  })
+})