diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..5e29675
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,29 @@
+name: Test
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20, 22]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100644
index 0000000..7b8ae37
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1,13 @@
+# Lint + tests before allowing commit — same gate as `task check`.
+# Set SKIP_TESTS=1 to skip the heavier test suite (lint still runs).
+
+set -e
+
+if command -v task >/dev/null 2>&1; then
+  task check
+else
+  npm run lint
+  if [ -z "$SKIP_TESTS" ]; then
+    npm test
+  fi
+fi
diff --git a/README.md b/README.md
index 3d23a6d..f07b504 100644
--- a/README.md
+++ b/README.md
@@ -78,14 +78,38 @@ Grab the latest release for your platform:
   - **Linux**: `build-essential`, `python3` (`sudo apt install build-essential python3`)
   - **Windows**: Visual Studio Build Tools or `npm install -g windows-build-tools`
 
+## Tooling
+
+[task](https://taskfile.dev) is the preferred entrypoint for all dev operations. Install it once (`brew install go-task` / `snap install task --classic` / see taskfile.dev for other platforms), then:
+
+```bash
+task install       # npm install
+task dev           # launch Electron (--no-sandbox, required on Linux)
+task test          # node --test  (24 tests)
+task lint          # eslint .
+task check         # test + lint  — pre-commit / pre-push gate
+task ci            # same as check but sequential, verbose
+task build         # npm run build:linux
+task clean         # wipe dist/, codemirror bundle, local DB (asks for confirmation)
+task db:reset      # wipe ~/.switchboard/switchboard.db only
+```
+
+Run `task` (no args) to list all tasks with descriptions.
+
+The npm scripts are still present and work as before; `task` just wraps them as a consistent entrypoint.
+
 ## Development Setup
 
 ```bash
-# Install dependencies (runs postinstall automatically)
-npm install
+task install   # install dependencies (runs postinstall automatically)
+task dev       # launch Electron
+```
 
-# Start the app
-npm start
+Or with npm directly:
+
+```bash
+npm install
+npm start      # bundles CodeMirror then launches Electron
 ```
 
 `npm start` bundles CodeMirror and launches Electron. For faster iteration after the first run:
@@ -99,10 +123,9 @@ npm run electron
 All build commands bundle CodeMirror first, then invoke electron-builder.
 
 ```bash
-# Current platform
-npm run build
+task build            # AppImage + deb (Linux)
 
-# Platform-specific
+# npm equivalents:
 npm run build:mac     # DMG + zip (arm64 + x64)
 npm run build:win     # NSIS installer (x64 + arm64)
 npm run build:linux   # AppImage + deb (x64 + arm64)
diff --git a/Taskfile.yaml b/Taskfile.yaml
new file mode 100644
index 0000000..1a68274
--- /dev/null
+++ b/Taskfile.yaml
@@ -0,0 +1,100 @@
+# https://taskfile.dev
+
+version: "3"
+
+set: [pipefail]
+
+vars:
+  SWITCHBOARD_DB: "{{.HOME}}/.switchboard/switchboard.db"
+  SWITCHBOARD_DEV_DATA_DIR: "{{.HOME}}/.switchboard-dev"
+
+tasks:
+  default:
+    desc: List all available tasks
+    silent: true
+    cmds:
+      - task --list
+
+  install:
+    desc: Install npm dependencies
+    cmds:
+      - npm install
+
+  dev:
+    desc: Launch Switchboard in development mode (Electron, no-sandbox, isolated DB)
+    silent: true
+    env:
+      # Force a separate SQLite DB so a running AppImage isn't disturbed by the
+      # dev electron sharing session_cache. Override per-run with
+      # `SWITCHBOARD_DATA_DIR=/some/other/dir task dev`.
+      SWITCHBOARD_DATA_DIR: "{{.SWITCHBOARD_DEV_DATA_DIR}}"
+    cmds:
+      - npx electron . --no-sandbox
+
+  "db:reset:dev":
+    desc: Wipe just the dev SQLite database
+    cmds:
+      - rm -f "{{.SWITCHBOARD_DEV_DATA_DIR}}/switchboard.db" "{{.SWITCHBOARD_DEV_DATA_DIR}}/switchboard.db-wal" "{{.SWITCHBOARD_DEV_DATA_DIR}}/switchboard.db-shm"
+      - echo "Removed {{.SWITCHBOARD_DEV_DATA_DIR}}/switchboard.db"
+
+  build:
+    desc: Build Linux distribution packages (AppImage + deb)
+    silent: true
+    cmds:
+      - npm run build:linux
+
+  test:
+    desc: Run the node:test suite (24 tests)
+    cmds:
+      - npm test
+
+  lint:
+    desc: Run ESLint across the codebase
+    cmds:
+      - |
+        if [ ! -f eslint.config.js ] && [ ! -f .eslintrc.js ] && [ ! -f .eslintrc.json ] && [ ! -f .eslintrc.yaml ] && [ ! -f .eslintrc.yml ]; then
+          echo "ESLint not yet configured; run \`task install:lint\` first"
+          exit 1
+        fi
+        npx eslint .
+
+  "install:lint":
+    desc: Install ESLint + jsdom dev deps (idempotent)
+    cmds:
+      - |
+        MISSING=""
+        node -e "require('eslint')" 2>/dev/null || MISSING="$MISSING eslint"
+        node -e "require('jsdom')" 2>/dev/null || MISSING="$MISSING jsdom"
+        if [ -n "$MISSING" ]; then
+          npm install --save-dev $MISSING
+        else
+          echo "ESLint and jsdom already installed — nothing to do."
+        fi
+
+  check:
+    desc: Run tests + lint (pre-commit / pre-push gate)
+    deps: [test, lint]
+
+  ci:
+    desc: CI gate — runs test then lint, verbose, exits on first failure
+    cmds:
+      - npm test
+      - npx eslint .
+
+  clean:
+    desc: Remove dist/, codemirror bundle, and local DB (asks for confirmation)
+    interactive: true
+    cmds:
+      - |
+        read -p "This will delete dist/, public/codemirror-bundle.js, and {{.SWITCHBOARD_DB}}. Type YES to confirm: " ans
+        [ "$ans" = "YES" ]
+      - rm -rf dist/
+      - rm -f public/codemirror-bundle.js
+      - rm -f "{{.SWITCHBOARD_DB}}"
+      - echo "Clean complete."
+
+  "db:reset":
+    desc: Wipe the local Switchboard SQLite database (no confirmation)
+    cmds:
+      - rm -f "{{.SWITCHBOARD_DB}}"
+      - echo "Removed {{.SWITCHBOARD_DB}}"
diff --git a/db.js b/db.js
index 4fabae4..ef9d5de 100644
--- a/db.js
+++ b/db.js
@@ -2,7 +2,13 @@ const Database = require('better-sqlite3');
 const path = require('path');
 const os = require('os');
 
-const DATA_DIR = path.join(os.homedir(), '.switchboard');
+// SWITCHBOARD_DATA_DIR lets dev/agent runs use a separate DB from the
+// installed AppImage so they don't race on session_cache. Default stays
+// ~/.switchboard so existing installs keep working. Resolve env var at
+// require-time (any later mutation would be ignored).
+const DATA_DIR = process.env.SWITCHBOARD_DATA_DIR
+  ? path.resolve(process.env.SWITCHBOARD_DATA_DIR.replace(/^~(?=$|\/)/, os.homedir()))
+  : path.join(os.homedir(), '.switchboard');
 const fs = require('fs');
 if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
 
@@ -14,7 +20,11 @@ const OLD_LOCATIONS = [
   path.join(os.homedir(), '.claude', 'browser', 'session-browser.db'),
   path.join(os.homedir(), '.claude', 'session-browser.db'),
 ];
-if (!fs.existsSync(DB_PATH)) {
+// Skip the legacy ~/.claude/browser/ migration when running with a custom
+// DATA_DIR (typical dev/agent setup) — otherwise a fresh dev DB would steal
+// the AppImage's old data on first launch.
+const IS_DEFAULT_DATA_DIR = !process.env.SWITCHBOARD_DATA_DIR;
+if (IS_DEFAULT_DATA_DIR && !fs.existsSync(DB_PATH)) {
   for (const oldPath of OLD_LOCATIONS) {
     if (fs.existsSync(oldPath)) {
       fs.renameSync(oldPath, DB_PATH);
@@ -49,7 +59,11 @@ db.exec(`
     modified TEXT,
     messageCount INTEGER DEFAULT 0,
     slug TEXT,
-    aiTitle TEXT
+    aiTitle TEXT,
+    parentSessionId TEXT,
+    agentId TEXT,
+    subagentType TEXT,
+    description TEXT
   )
 `);
 
@@ -99,6 +113,20 @@ const migrations = [
     try { db.exec('DELETE FROM session_cache'); } catch {}
     try { db.exec('DELETE FROM cache_meta'); } catch {}
   },
+  // v4: Add subagent columns. Subagent transcripts live under
+  // <folder>/<parentSessionId>/subagents/agent-<agentId>.jsonl alongside a
+  // .meta.json sidecar holding { agentType, description }. We surface them as
+  // first-class rows in session_cache, keyed by sessionId = "sub:<parent>:<agentId>".
+  // Clear cache so subagent rows get picked up on first re-index.
+  (db) => {
+    try { db.exec('ALTER TABLE session_cache ADD COLUMN parentSessionId TEXT'); } catch {}
+    try { db.exec('ALTER TABLE session_cache ADD COLUMN agentId TEXT'); } catch {}
+    try { db.exec('ALTER TABLE session_cache ADD COLUMN subagentType TEXT'); } catch {}
+    try { db.exec('ALTER TABLE session_cache ADD COLUMN description TEXT'); } catch {}
+    try { db.exec('CREATE INDEX IF NOT EXISTS idx_session_cache_parent ON session_cache(parentSessionId)'); } catch {}
+    try { db.exec('DELETE FROM session_cache'); } catch {}
+    try { db.exec('DELETE FROM cache_meta'); } catch {}
+  },
 ];
 
 const currentDbVersion = (() => {
@@ -152,20 +180,24 @@ const stmts = {
   cacheCount: db.prepare('SELECT COUNT(*) as cnt FROM session_cache'),
   cacheGetAll: db.prepare('SELECT * FROM session_cache'),
   cacheUpsert: db.prepare(`
-    INSERT INTO session_cache (sessionId, folder, projectPath, summary, firstPrompt, created, modified, messageCount, slug, aiTitle)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO session_cache (sessionId, folder, projectPath, summary, firstPrompt, created, modified, messageCount, slug, aiTitle, parentSessionId, agentId, subagentType, description)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT(sessionId) DO UPDATE SET
       folder = excluded.folder, projectPath = excluded.projectPath,
       summary = excluded.summary, firstPrompt = excluded.firstPrompt,
       created = excluded.created, modified = excluded.modified,
       messageCount = excluded.messageCount, slug = excluded.slug,
-      aiTitle = excluded.aiTitle
+      aiTitle = excluded.aiTitle,
+      parentSessionId = excluded.parentSessionId, agentId = excluded.agentId,
+      subagentType = excluded.subagentType, description = excluded.description
   `),
-  cacheGetByFolder: db.prepare('SELECT sessionId, modified FROM session_cache WHERE folder = ?'),
+  cacheGetByParent: db.prepare('SELECT * FROM session_cache WHERE parentSessionId = ? ORDER BY created ASC'),
+  cacheGetByFolder: db.prepare('SELECT * FROM session_cache WHERE folder = ?'),
   cacheGetFolder: db.prepare('SELECT folder FROM session_cache WHERE sessionId = ?'),
   cacheGetSession: db.prepare('SELECT * FROM session_cache WHERE sessionId = ?'),
   cacheDeleteSession: db.prepare('DELETE FROM session_cache WHERE sessionId = ?'),
   cacheDeleteFolder: db.prepare('DELETE FROM session_cache WHERE folder = ?'),
+  cacheTouchModified: db.prepare('UPDATE session_cache SET modified = ? WHERE sessionId = ?'),
   // Cache meta statements
   metaGet: db.prepare('SELECT * FROM cache_meta WHERE folder = ?'),
   metaGetAll: db.prepare('SELECT * FROM cache_meta'),
@@ -246,11 +278,17 @@ const upsertCachedSessionsBatch = db.transaction((sessions) => {
     stmts.cacheUpsert.run(
       s.sessionId, s.folder, s.projectPath, s.summary,
       s.firstPrompt, s.created, s.modified, s.messageCount || 0,
-      s.slug || null, s.aiTitle || null
+      s.slug || null, s.aiTitle || null,
+      s.parentSessionId || null, s.agentId || null,
+      s.subagentType || null, s.description || null
     );
   }
 });
 
+function getCachedByParent(parentSessionId) {
+  return stmts.cacheGetByParent.all(parentSessionId);
+}
+
 function upsertCachedSessions(sessions) {
   upsertCachedSessionsBatch(sessions);
 }
@@ -370,17 +408,39 @@ function deleteSetting(key) {
   stmts.settingsDelete.run(key);
 }
 
+// --- Daily activity aggregate (for stats heatmap) ---
+
+// Returns [{date: 'YYYY-MM-DD', messageCount, sessionCount}, ...] sorted ASC.
+// Aggregates ALL rows in session_cache (parent sessions + subagents) so the
+// heatmap reflects real usage regardless of whether Claude rotated the parent
+// JSONL files.
+function getDailyActivity() {
+  return db.prepare(`
+    SELECT
+      substr(modified, 1, 10) AS date,
+      SUM(messageCount)       AS messageCount,
+      COUNT(*)                AS sessionCount
+    FROM session_cache
+    WHERE modified IS NOT NULL
+      AND length(modified) >= 10
+    GROUP BY date
+    ORDER BY date ASC
+  `).all();
+}
+
 function closeDb() {
   try { db.close(); } catch {}
 }
 
 module.exports = {
   getMeta, getAllMeta, setName, toggleStar, setArchived,
-  isCachePopulated, getAllCached, getCachedByFolder, getCachedFolder, getCachedSession, upsertCachedSessions,
+  isCachePopulated, getAllCached, getCachedByFolder, getCachedByParent, getCachedFolder, getCachedSession, upsertCachedSessions,
+  touchCachedModified: (sessionId, modified) => stmts.cacheTouchModified.run(modified, sessionId),
   deleteCachedSession, deleteCachedFolder,
   getFolderMeta, getAllFolderMeta, setFolderMeta,
   upsertSearchEntries, updateSearchTitle, deleteSearchSession, deleteSearchFolder, deleteSearchType,
   searchByType, isSearchIndexPopulated, searchFtsRecreated,
   getSetting, setSetting, deleteSetting,
+  getDailyActivity,
   closeDb,
 };
diff --git a/derive-project-path.js b/derive-project-path.js
index f563e35..829da5e 100644
--- a/derive-project-path.js
+++ b/derive-project-path.js
@@ -33,7 +33,7 @@ function deriveProjectPath(folderPath) {
     for (const e of entries) {
       if (e.isFile() && e.name.endsWith('.jsonl')) {
         const cwd = extractCwdFromJsonl(path.join(folderPath, e.name));
-        if (cwd) return cwd;
+        if (cwd) return resolveWorktreePath(cwd);
       }
     }
     // Check session subdirectories (UUID folders with subagent .jsonl files)
@@ -52,7 +52,7 @@ function deriveProjectPath(folderPath) {
           }
           if (jsonlPath) {
             const cwd = extractCwdFromJsonl(jsonlPath);
-            if (cwd) return cwd;
+            if (cwd) return resolveWorktreePath(cwd);
           }
         }
       } catch {}
@@ -61,4 +61,4 @@ function deriveProjectPath(folderPath) {
   return null;
 }
 
-module.exports = { deriveProjectPath };
+module.exports = { deriveProjectPath, resolveWorktreePath };
diff --git a/eslint.config.js b/eslint.config.js
new file mode 100644
index 0000000..81ede52
--- /dev/null
+++ b/eslint.config.js
@@ -0,0 +1,305 @@
+// ESLint flat config for Switchboard (ESLint 9.x).
+//
+// Goals:
+//   1. Catch dumb "undefined variable" mistakes in renderer code
+//      (no-undef). Two recent regressions in public/sidebar.js
+//      (subagentIndex undefined; project.projectPath out of scope)
+//      would have been caught instantly by this rule.
+//   2. Warn about unused vars without blocking the build.
+//   3. Keep the existing 24+ node:test suite green.
+//
+// The renderer (public/*.js) loads as a set of classic <script> tags
+// in index.html: every top-level `function`, `const`, `let` becomes a
+// global accessible to sibling files. ESLint treats each file in
+// isolation, so we declare the cross-file globals (defined in app.js
+// per the comment at the top of sidebar.js) as readonly browser globals.
+//
+// Main-process files (CommonJS) get a separate block with node globals.
+
+const globals = require('globals');
+
+// Cross-file renderer globals: vars defined in one file and consumed by
+// another. The list mirrors the dependency comment at the top of
+// public/sidebar.js (and equivalents). Kept readonly so reassignment
+// from another file gets flagged.
+const rendererCrossFileGlobals = {
+  // DOM element handles (defined in app.js)
+  sidebarContent: 'readonly',
+  plansContent: 'readonly',
+  statsContent: 'readonly',
+  memoryContent: 'readonly',
+  placeholder: 'readonly',
+  terminalsEl: 'readonly',
+  terminalArea: 'readonly',
+  terminalHeader: 'readonly',
+  terminalHeaderName: 'readonly',
+  terminalHeaderId: 'readonly',
+  terminalHeaderStatus: 'readonly',
+  terminalHeaderShell: 'readonly',
+  terminalStopBtn: 'readonly',
+  archiveToggle: 'readonly',
+  starToggle: 'readonly',
+  runningToggle: 'readonly',
+  todayToggle: 'readonly',
+  searchInput: 'readonly',
+  searchBar: 'readonly',
+  sessionFilters: 'readonly',
+  loadingStatus: 'readonly',
+  statusBarInfo: 'readonly',
+  statusBarActivity: 'readonly',
+  planViewer: 'readonly',
+  planPanel: 'readonly',
+  memoryViewer: 'readonly',
+  memoryPanel: 'readonly',
+  statsViewer: 'readonly',
+  statsViewerBody: 'readonly',
+  settingsViewer: 'readonly',
+  globalSettingsBtn: 'readonly',
+  addProjectBtn: 'readonly',
+  resortBtn: 'readonly',
+  jsonlViewer: 'readonly',
+  jsonlViewerTitle: 'readonly',
+  jsonlViewerSessionId: 'readonly',
+  jsonlViewerBody: 'readonly',
+  gridViewer: 'readonly',
+  gridViewerCount: 'readonly',
+
+  // Sidebar/session state (mutable in app.js but readonly from sibling files)
+  openSessions: 'readonly',
+  activeSessionId: 'writable', // reassigned in setActiveSession
+  setActiveSession: 'readonly',
+  activePtyIds: 'writable',
+  pendingSessions: 'readonly',
+  sessionMap: 'writable',
+  lastActivityTime: 'readonly',
+  sortedOrder: 'writable',
+  searchMatchIds: 'writable',
+  searchMatchProjectPaths: 'writable',
+  showArchived: 'writable',
+  showStarredOnly: 'writable',
+  showRunningOnly: 'writable',
+  showTodayOnly: 'writable',
+  visibleSessionCount: 'writable',
+  sessionMaxAgeDays: 'writable',
+  attentionSessions: 'readonly',
+  responseReadySessions: 'readonly',
+  sessionBusyState: 'readonly',
+  cachedProjects: 'writable',
+  cachedAllProjects: 'writable',
+  cachedPlans: 'writable',
+  gridCards: 'writable',
+  gridViewActive: 'writable',
+  activeTab: 'writable',
+
+  // Functions from app.js / dialogs.js / utils.js / icons.js / terminal-manager.js / etc.
+  ICONS: 'readonly',
+  cleanDisplayName: 'readonly',
+  formatDate: 'readonly',
+  escapeHtml: 'readonly',
+  shellEscape: 'readonly',
+  encodeProjectPath: 'readonly',
+  showSession: 'readonly',
+  confirmAndStopSession: 'readonly',
+  pollActiveSessions: 'readonly',
+  showNewSessionPopover: 'readonly',
+  openSettingsViewer: 'readonly',
+  showResumeSessionDialog: 'readonly',
+  showJsonlViewer: 'readonly',
+  forkSession: 'readonly',
+  openSession: 'readonly',
+  loadProjects: 'readonly',
+  renderProjects: 'readonly',
+  renderPlans: 'readonly',
+  buildSubagentIndex: 'readonly',
+  buildSubagentItem: 'readonly',
+  appendSubagentChildren: 'readonly',
+  buildSessionItem: 'readonly',
+  buildSlugGroup: 'readonly',
+  folderId: 'readonly',
+  slugId: 'readonly',
+  subagentTypeColor: 'readonly',
+  getExpandedSubagents: 'readonly',
+  saveExpandedSubagents: 'readonly',
+  getExpandedSlugs: 'readonly',
+  saveExpandedSlugs: 'readonly',
+  setActivity: 'readonly',
+  trackActivity: 'readonly',
+
+  // Third-party renderer libs loaded as <script>
+  morphdom: 'readonly',
+  marked: 'readonly',
+  ViewerPanel: 'readonly',
+
+  // Switchboard preload bridge
+  switchboardAPI: 'readonly',
+  // electronAPI / window.api possibly exposed via preload — leave as readonly
+  electronAPI: 'readonly',
+
+  // xterm.js and addons (loaded via <script>, exposed as window.Terminal etc.)
+  Terminal: 'readonly',
+  FitAddon: 'readonly',
+  SearchAddon: 'readonly',
+  WebLinksAddon: 'readonly',
+  WebglAddon: 'readonly',
+  UnicodeGraphemesAddon: 'readonly',
+
+  // Terminal/grid/file-panel/plans/stats/notifications and assorted helpers
+  // shared across renderer files (defined somewhere in public/*.js).
+  TERMINAL_THEME: 'writable',
+  TERMINAL_THEMES: 'readonly',
+  getTerminalTheme: 'readonly',
+  currentThemeName: 'writable',
+  isMac: 'readonly',
+  flashButtonText: 'readonly',
+  toggleMarkdownPreview: 'readonly',
+  refreshSidebar: 'readonly',
+  updateRunningIndicators: 'readonly',
+  hideAllViewers: 'readonly',
+  hidePlanViewer: 'readonly',
+  showTerminalHeader: 'readonly',
+  switchPanel: 'readonly',
+  showAddProjectDialog: 'readonly',
+  showGridView: 'readonly',
+  toggleGridView: 'readonly',
+  focusGridCard: 'readonly',
+  wrapInGridCard: 'readonly',
+  initGridObservers: 'readonly',
+  initFilePanel: 'readonly',
+  openFileInPanel: 'readonly',
+  rekeyFilePanelState: 'readonly',
+  loadPlans: 'readonly',
+  loadStats: 'readonly',
+  loadMemories: 'readonly',
+  renderMemories: 'readonly',
+  clearNotifications: 'readonly',
+  setSessionMcpActive: 'readonly',
+  destroySession: 'readonly',
+  launchNewSession: 'readonly',
+  launchTerminalSession: 'readonly',
+  launchScheduleCreator: 'readonly',
+  resolveDefaultSessionOptions: 'readonly',
+  handleSessionNavKey: 'readonly',
+  isSessionNavKey: 'readonly',
+  fitAndScroll: 'readonly',
+  safeFit: 'readonly',
+  flushTerminalBuffer: 'readonly',
+  scheduleFlush: 'readonly',
+  createTerminalEntry: 'readonly',
+  terminalWriteBuffers: 'readonly',
+  ESC_SYNC_START: 'readonly',
+  ESC_SYNC_END: 'readonly',
+  SYNC_BUFFER_TIMEOUT: 'readonly',
+  updatePtyTitle: 'readonly',
+  _shellProfiles: 'writable',
+};
+
+module.exports = [
+  // Ignore generated/vendored bundles and binaries
+  {
+    ignores: [
+      'node_modules/**',
+      'dist/**',
+      'build/**',
+      'public/codemirror-bundle.js',
+      'scripts/**', // ad-hoc build helpers; out of lint scope for now
+      '.work-files/**',
+    ],
+  },
+
+  // Renderer process: classic <script> globals, browser context
+  {
+    files: ['public/**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'script',
+      globals: {
+        ...globals.browser,
+        ...rendererCrossFileGlobals,
+      },
+    },
+    rules: {
+      'no-undef': 'error',
+      'no-unused-vars': ['warn', { args: 'none', varsIgnorePattern: '^_' }],
+      'no-implicit-globals': 'off', // renderer relies on script-scope globals by design
+      'no-empty': ['warn', { allowEmptyCatch: true }],
+      'no-unreachable': 'warn',
+      'no-redeclare': 'warn',
+    },
+  },
+
+  // CodeMirror setup file uses ESM-style imports/closure that don't lint well
+  // as a classic script — keep no-undef on but be permissive about unused.
+  {
+    files: ['public/codemirror-setup.js'],
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'module',
+      globals: { ...globals.browser },
+    },
+    rules: {
+      'no-undef': 'error',
+      'no-unused-vars': 'off',
+    },
+  },
+
+  // Main process: CommonJS, Node + Electron
+  {
+    files: [
+      'main.js',
+      'preload.js',
+      'db.js',
+      'session-cache.js',
+      'session-transitions.js',
+      'read-session-file.js',
+      'derive-project-path.js',
+      'encode-project-path.js',
+      'folder-index-state.js',
+      'claude-auth.js',
+      'mcp-bridge.js',
+      'schedule-ipc.js',
+      'schedule-runner.js',
+      'shell-profiles.js',
+      'workers/**/*.js',
+    ],
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'commonjs',
+      globals: {
+        ...globals.node,
+      },
+    },
+    rules: {
+      'no-undef': 'error',
+      'no-unused-vars': ['warn', { args: 'none', varsIgnorePattern: '^_' }],
+      'no-empty': ['warn', { allowEmptyCatch: true }],
+      'no-unreachable': 'warn',
+      'no-redeclare': 'warn',
+    },
+  },
+
+  // Tests: node:test, Node globals
+  {
+    files: ['test/**/*.js', 'test/**/*.test.js'],
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'commonjs',
+      globals: {
+        ...globals.node,
+      },
+    },
+    rules: {
+      'no-undef': 'error',
+      'no-unused-vars': ['warn', { args: 'none', varsIgnorePattern: '^_' }],
+    },
+  },
+
+  // ESLint config self-check
+  {
+    files: ['eslint.config.js'],
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'commonjs',
+      globals: { ...globals.node },
+    },
+  },
+];
diff --git a/main.js b/main.js
index 2c587b7..1980054 100644
--- a/main.js
+++ b/main.js
@@ -1,10 +1,20 @@
 const { app, BrowserWindow, dialog, ipcMain, Menu, screen, shell } = require('electron');
 const { Worker } = require('worker_threads');
+const { execFile } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const pty = require('node-pty');
 const log = require('electron-log');
+
+// Dev builds default to a separate SQLite DB so they don't race on
+// session_cache with a running installed AppImage. Honors an explicit
+// SWITCHBOARD_DATA_DIR env var if set (test sandboxes, agent runs). This MUST
+// happen before db.js is required — db.js resolves DATA_DIR at module load.
+if (!app.isPackaged && !process.env.SWITCHBOARD_DATA_DIR) {
+  process.env.SWITCHBOARD_DATA_DIR = path.join(os.homedir(), '.switchboard-dev');
+}
+
 // getFolderIndexMtimeMs moved to session-cache.js
 const { startMcpServer, shutdownMcpServer, shutdownAll: shutdownAllMcp, resolvePendingDiff, rekeyMcpServer, cleanStaleLockFiles } = require('./mcp-bridge');
 const { fetchAndTransformUsage } = require('./claude-auth');
@@ -61,12 +71,13 @@ if (app.isPackaged || process.env.FORCE_UPDATER) {
 }
 const {
   getMeta, getAllMeta, toggleStar, setName, setArchived,
-  isCachePopulated, getAllCached, getCachedByFolder, getCachedFolder, getCachedSession, upsertCachedSessions,
+  isCachePopulated, getAllCached, getCachedByFolder, getCachedByParent, getCachedFolder, getCachedSession, upsertCachedSessions,
   deleteCachedSession, deleteCachedFolder,
   getFolderMeta, getAllFolderMeta, setFolderMeta,
   upsertSearchEntries, updateSearchTitle, deleteSearchSession, deleteSearchFolder, deleteSearchType,
   searchByType, isSearchIndexPopulated, searchFtsRecreated,
   getSetting, setSetting, deleteSetting,
+  getDailyActivity,
   closeDb,
 } = require('./db');
 
@@ -80,6 +91,10 @@ const MAX_BUFFER_SIZE = 256 * 1024;
 const activeSessions = new Map();
 let mainWindow = null;
 
+// Subagent live-tail watchers (watchId → { filePath, parentSessionId, agentId })
+const subagentWatchers = new Map();
+let subagentWatcherSeq = 0;
+
 function createWindow() {
   // Restore saved window bounds
   const savedBounds = getSetting('global')?.windowBounds;
@@ -104,11 +119,12 @@ function createWindow() {
     }
   }
 
+  const appTitle = app.isPackaged ? 'Switchboard' : 'Switchboard (dev)';
   mainWindow = new BrowserWindow({
     ...bounds,
     minWidth: 800,
     minHeight: 500,
-    title: 'Switchboard',
+    title: appTitle,
     icon: path.join(__dirname, 'build', 'icon.png'),
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
@@ -123,6 +139,9 @@ function createWindow() {
   }
 
   mainWindow.loadFile(path.join(__dirname, 'public', 'index.html'));
+  mainWindow.webContents.on('console-message', (_e, level, message, line, sourceId) => {
+    if (level >= 2) log.error(`[renderer:${level}] ${sourceId}:${line} ${message}`);
+  });
 
   // Open external links in the system browser instead of a child BrowserWindow
   mainWindow.webContents.setWindowOpenHandler(({ url }) => {
@@ -202,6 +221,11 @@ function createWindow() {
       }
       activeSessions.delete(id);
     }
+    // Release all subagent file watchers
+    for (const [, entry] of subagentWatchers) {
+      try { fs.unwatchFile(entry.filePath); } catch {}
+    }
+    subagentWatchers.clear();
     mainWindow = null;
   });
 }
@@ -342,6 +366,84 @@ ipcMain.handle('remove-project', (_event, projectPath) => {
   }
 });
 
+// --- IPC: delete-worktree ---
+// Validated path pattern: <project>/.<segment>/[worktrees/]<name>
+// Matches .claude/worktrees/<n>, .claude-worktrees/<n>, .worktrees/<n>
+const WORKTREE_PATH_RE = /^(.+?)\/\.(?:claude\/worktrees|claude-worktrees|worktrees)\/([^/]+)\/?$/;
+
+ipcMain.handle('delete-worktree', (_event, worktreePath) => {
+  return new Promise((resolve) => {
+    // Normalize trailing slash
+    const normalizedPath = worktreePath.replace(/\/$/, '');
+
+    // Validate path matches a known worktree layout
+    const match = normalizedPath.match(WORKTREE_PATH_RE);
+    if (!match) {
+      return resolve({ ok: false, error: 'Path does not match a recognized worktree layout' });
+    }
+    const parentRepo = match[1];
+
+    // Helper: run git worktree remove, optionally double-force
+    function runRemove(doubleForce, callback) {
+      const args = ['-C', parentRepo, 'worktree', 'remove', '-f'];
+      if (doubleForce) args.push('-f');
+      args.push('--', normalizedPath);
+      execFile('git', args, (err, _stdout, stderr) => callback(err, stderr));
+    }
+
+    runRemove(false, (err, stderr) => {
+      if (err && /locked/i.test(stderr || err.message || '')) {
+        // Retry with double force for locked worktrees
+        runRemove(true, (err2, stderr2) => {
+          if (err2) return resolve({ ok: false, error: (stderr2 || err2.message || String(err2)).trim() });
+          afterRemove();
+        });
+      } else if (err) {
+        return resolve({ ok: false, error: (stderr || err.message || String(err)).trim() });
+      } else {
+        afterRemove();
+      }
+    });
+
+    function afterRemove() {
+      // Clean up DB cache: delete all sessions whose projectPath matches worktreePath
+      let removed = 0;
+      try {
+        const allRows = getAllCached();
+        for (const row of allRows) {
+          if (row.projectPath === normalizedPath) {
+            deleteCachedSession(row.sessionId);
+            deleteSearchSession(row.sessionId);
+            removed++;
+          }
+        }
+      } catch (dbErr) {
+        log.warn('[delete-worktree] DB cleanup error:', dbErr.message);
+      }
+
+      // Remove from hiddenProjects if present
+      try {
+        const global = getSetting('global') || {};
+        if (Array.isArray(global.hiddenProjects) && global.hiddenProjects.includes(normalizedPath)) {
+          global.hiddenProjects = global.hiddenProjects.filter(p => p !== normalizedPath);
+          setSetting('global', global);
+        }
+      } catch {}
+
+      // Also clean up folder meta
+      try {
+        const folder = encodeProjectPath(normalizedPath);
+        deleteCachedFolder(folder);
+        deleteSearchFolder(folder);
+      } catch {}
+
+      log.info(`[delete-worktree] removed=${normalizedPath} sessions=${removed}`);
+      notifyRendererProjectsChanged();
+      resolve({ ok: true, removed });
+    }
+  });
+});
+
 // --- IPC: get-projects ---
 ipcMain.handle('open-external', (_event, url) => {
   log.info('[open-external IPC]', url);
@@ -407,13 +509,33 @@ ipcMain.handle('unwatch-file', (_event, filePath) => {
   return { ok: true };
 });
 
-ipcMain.handle('get-projects', (_event, showArchived) => {
+// Full re-scan triggered from the UI. Re-reads every jsonl file in the worker
+// thread, which is the only path that rebuilds search_fts with the live tail
+// of active sessions (refreshFolder uses a header-only read by design — see
+// session-cache.js). Concurrent callers share the same in-flight worker via
+// populateCacheViaWorker's internal Promise.
+ipcMain.handle('rebuild-cache', async () => {
+  try {
+    await populateCacheViaWorker();
+    return { ok: true };
+  } catch (err) {
+    console.error('Error rebuilding cache:', err);
+    return { ok: false, error: err.message };
+  }
+});
+
+ipcMain.handle('get-projects', async (_event, showArchived) => {
   try {
     const needsPopulate = !isCachePopulated() || !isSearchIndexPopulated();
 
     if (needsPopulate) {
-      populateCacheViaWorker();
-      return [];
+      // First call after a migration that clears session_cache (e.g. v4) finds
+      // an empty cache. Returning [] immediately makes the renderer paint an
+      // empty list and rely on `notifyRendererProjectsChanged` firing later —
+      // which only triggers a reload if the user is on the Sessions tab. To
+      // avoid that race, await the scan here so the response carries the
+      // freshly-populated cache. Concurrent callers share the same Promise.
+      await populateCacheViaWorker();
     }
 
     return buildProjectsFromCache(showArchived);
@@ -499,108 +621,69 @@ ipcMain.handle('get-stats', () => {
   }
 });
 
-// --- IPC: refresh-stats (run /stats + /usage via PTY) ---
-ipcMain.handle('refresh-stats', async () => {
-  // For stats, use the configured shell profile
-  const globalSettings = getSetting('global') || {};
-  const statsProfileId = globalSettings.shellProfile || SETTING_DEFAULTS.shellProfile;
-  const statsShellProfile = resolveShell(statsProfileId);
-  const statsShell = statsShellProfile.path;
-  const statsShellExtraArgs = statsShellProfile.args || [];
-  const ptyEnv = {
-    ...cleanPtyEnv,
-    TERM: 'xterm-256color',
-    COLORTERM: 'truecolor',
-    TERM_PROGRAM: 'iTerm.app',
-    TERM_PROGRAM_VERSION: '3.6.6',
-    FORCE_COLOR: '3',
-    ITERM_SESSION_ID: '1',
-  };
-
-  // Helper: spawn claude with args, collect output, auto-accept trust, kill when idle
-  // waitFor: optional regex tested against stripped output — finish only when matched
-  function runClaude(args, { timeoutMs = 15000, waitFor = null } = {}) {
-    return new Promise((resolve) => {
-      let output = '';
-      let settled = false;
-      let trustAccepted = false;
-      // Track idle: ✳ in OSC title means Claude is idle and waiting for input
-      let sawActivity = false;
-
-      const finish = () => {
-        if (settled) return;
-        settled = true;
-        try { p.kill(); } catch {}
-        resolve(output);
-      };
-
-      const claudeCmd = `claude ${args}`;
-      const p = pty.spawn(statsShell, shellArgs(statsShell, claudeCmd, statsShellExtraArgs), {
-        name: 'xterm-256color',
-        cols: 120,
-        rows: 40,
-        cwd: os.homedir(),
-        env: ptyEnv,
-      });
-
-      const strip = (s) => s
-        .replace(/\x1b\[[^@-~]*[@-~]/g, '')
-        .replace(/\x1b\][^\x07]*\x07/g, '')
-        .replace(/\x1b[^[\]].?/g, '');
-
-      p.onData((data) => {
-        output += data;
-
-        // Auto-accept trust directory prompt (Enter selects "1. Yes")
-        if (!trustAccepted) {
-          if (/trust\s*this\s*folder/i.test(strip(output))) {
-            trustAccepted = true;
-            try { p.write('\r'); } catch {}
-            return;
-          }
-        }
-
-        // If waitFor is set, finish when that pattern appears in stripped output
-        if (waitFor) {
-          if (waitFor.test(strip(output))) {
-            finish();
-          }
-          return;
-        }
-
-        // Default: detect busy→idle transition via OSC title containing ✳
-        if (!sawActivity) {
-          const oscTitle = data.match(/\x1b\]0;([^\x07\x1b]*)/);
-          if (oscTitle) {
-            const first = oscTitle[1].charAt(0);
-            if (first.charCodeAt(0) >= 0x2800 && first.charCodeAt(0) <= 0x28FF) {
-              sawActivity = true;
-            }
-          }
-        } else if (data.includes('\u2733')) {
-          finish();
-        }
-      });
-
-      p.onExit(() => finish());
-      setTimeout(finish, timeoutMs);
-    });
+// --- IPC: get-stats-from-db ---
+// Builds a stats object from session_cache so the heatmap reflects real usage
+// including subagent sessions (which claude /stats silently ignores) and
+// periods where Claude already rotated the parent JSONL files off disk.
+ipcMain.handle('get-stats-from-db', () => {
+  try {
+    const rows = getDailyActivity(); // [{date, messageCount, sessionCount}]
+    let totalMessages = 0;
+    let totalSessions = 0;
+    let firstSessionDate = null;
+    for (const row of rows) {
+      totalMessages += row.messageCount || 0;
+      totalSessions += row.sessionCount || 0;
+      if (!firstSessionDate) firstSessionDate = row.date;
+    }
+    const lastComputedDate = new Date().toISOString().slice(0, 10);
+    return {
+      dailyActivity: rows, // [{date, messageCount, sessionCount}]
+      totalMessages,
+      totalSessions,
+      firstSessionDate: firstSessionDate || lastComputedDate,
+      lastComputedDate,
+      // dailyModelTokens intentionally omitted — not tracked per-day in session_cache
+      modelUsage: {},
+    };
+  } catch (err) {
+    log.error('Error building stats from DB:', err);
+    return null;
   }
+});
 
+// --- IPC: refresh-stats (fetch /usage + build stats from DB; /stats PTY removed) ---
+ipcMain.handle('refresh-stats', async () => {
   try {
-    // Run /stats via PTY (for heatmap/chart data) and fetch usage via API in parallel
-    const [, usage] = await Promise.all([
-      runClaude('"/stats"', { waitFor: /streak/i, timeoutMs: 10000 }),
-      fetchAndTransformUsage().catch(() => ({})),
-    ]);
+    // /stats PTY call removed — heatmap is now sourced from session_cache via
+    // get-stats-from-db. Only /usage is fetched here (rate-limits panel).
+    const usage = await fetchAndTransformUsage().catch(() => ({}));
 
-    // Read refreshed stats cache
+    // Build stats from DB (same as get-stats-from-db) so the caller gets both
+    // at once and the renderer can update heatmap + usage in a single round-trip.
     let stats = null;
     try {
-      if (fs.existsSync(STATS_CACHE_PATH)) {
-        stats = JSON.parse(fs.readFileSync(STATS_CACHE_PATH, 'utf8'));
+      const rows = getDailyActivity();
+      let totalMessages = 0;
+      let totalSessions = 0;
+      let firstSessionDate = null;
+      for (const row of rows) {
+        totalMessages += row.messageCount || 0;
+        totalSessions += row.sessionCount || 0;
+        if (!firstSessionDate) firstSessionDate = row.date;
       }
-    } catch {}
+      const lastComputedDate = new Date().toISOString().slice(0, 10);
+      stats = {
+        dailyActivity: rows,
+        totalMessages,
+        totalSessions,
+        firstSessionDate: firstSessionDate || lastComputedDate,
+        lastComputedDate,
+        modelUsage: {},
+      };
+    } catch (dbErr) {
+      log.error('Error building stats from DB in refresh-stats:', dbErr);
+    }
 
     return { stats, usage: usage || {} };
   } catch (err) {
@@ -826,6 +909,10 @@ const SETTING_DEFAULTS = {
 };
 
 ipcMain.handle('get-shell-profiles', () => {
+  // TODO(lint): `_shellProfiles` is scoped inside shell-profiles.js and not
+  // reachable from here — this line is a no-op left over from a refactor.
+  // Kept as-is for now; tracked separately. See tests/eslint-and-renderer-coverage.
+  // eslint-disable-next-line no-undef
   _shellProfiles = null; // refresh on each request
   return getShellProfiles();
 });
@@ -907,6 +994,85 @@ ipcMain.handle('read-session-jsonl', (_event, sessionId) => {
   }
 });
 
+ipcMain.handle('read-subagent-jsonl', (_event, parentSessionId, agentId) => {
+  const row = getCachedSession('sub:' + parentSessionId + ':' + agentId);
+  if (!row) return { error: 'Subagent session not found in cache' };
+  const jsonlPath = path.join(PROJECTS_DIR, row.folder, parentSessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+  try {
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const entries = [];
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try { entries.push(JSON.parse(line)); } catch {}
+    }
+    return { entries };
+  } catch (err) {
+    return { error: err.message };
+  }
+});
+
+ipcMain.handle('list-subagents', (_event, parentSessionId) => {
+  return getCachedByParent(parentSessionId).map(r => ({
+    sessionId: r.sessionId,
+    agentId: r.agentId,
+    subagentType: r.subagentType,
+    description: r.description,
+    modified: r.modified,
+    messageCount: r.messageCount,
+  }));
+});
+
+// ── Subagent live-tail watchers ──────────────────────────────────────────────
+
+ipcMain.handle('start-subagent-watch', (_event, parentSessionId, agentId) => {
+  const row = getCachedSession('sub:' + parentSessionId + ':' + agentId);
+  if (!row) return { error: 'Subagent not found in cache' };
+  const filePath = path.join(PROJECTS_DIR, row.folder, parentSessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+
+  const watchId = ++subagentWatcherSeq;
+  let offset = 0;
+  // Seek to EOF so we only deliver *new* lines
+  try { offset = fs.statSync(filePath).size; } catch {}
+
+  function readNewEntries() {
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.size <= offset) return;
+      const buf = Buffer.alloc(stat.size - offset);
+      const fd = fs.openSync(filePath, 'r');
+      const bytesRead = fs.readSync(fd, buf, 0, buf.length, offset);
+      fs.closeSync(fd);
+      if (bytesRead <= 0) return;
+      offset += bytesRead;
+      const text = buf.toString('utf8', 0, bytesRead);
+      const entries = [];
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try { entries.push(JSON.parse(line)); } catch {}
+      }
+      if (entries.length > 0 && mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send('subagent-watch-event', { parentSessionId, agentId, entries });
+      }
+    } catch {}
+  }
+
+  // fs.watchFile gives reliable polling on Linux where inotify can be unreliable for JSONL appends
+  fs.watchFile(filePath, { interval: 1000, persistent: false }, readNewEntries);
+
+  subagentWatchers.set(watchId, { filePath, parentSessionId, agentId });
+  log.info(`[subagent-watch] start watchId=${watchId} parent=${parentSessionId} agentId=${agentId}`);
+  return { watchId };
+});
+
+ipcMain.handle('stop-subagent-watch', (_event, watchId) => {
+  const entry = subagentWatchers.get(watchId);
+  if (!entry) return { ok: false };
+  fs.unwatchFile(entry.filePath);
+  subagentWatchers.delete(watchId);
+  log.info(`[subagent-watch] stop watchId=${watchId}`);
+  return { ok: true };
+});
+
 ipcMain.handle('archive-session', (_event, sessionId, archived) => {
   const val = archived ? 1 : 0;
   setArchived(sessionId, val);
@@ -1304,20 +1470,31 @@ let projectsWatcher = null;
 function startProjectsWatcher() {
   if (!fs.existsSync(PROJECTS_DIR)) return;
 
-  const pendingFolders = new Set();
+  // pendingChanges: folder → Set<relativePath> | true.
+  //   Set<string>  — only the listed files changed (targeted refresh, fast path)
+  //   true         — folder-level event or unknown scope, do a full walk
+  // The watcher reports the specific filename, so for the common case of a
+  // subagent appending JSONL we can stat one file instead of thousands.
+  const pendingChanges = new Map();
   let debounceTimer = null;
 
   function flushChanges() {
     debounceTimer = null;
-    const folders = new Set(pendingFolders);
-    pendingFolders.clear();
+    // Drain pendingChanges into a local copy so events arriving during the
+    // synchronous flush land in a fresh batch for the next tick.
+    const work = new Map(pendingChanges);
+    pendingChanges.clear();
 
     let changed = false;
-    for (const folder of folders) {
+    for (const [folder, scope] of work) {
       const folderPath = path.join(PROJECTS_DIR, folder);
       if (fs.existsSync(folderPath)) {
         detectSessionTransitions(folder);
-        refreshFolder(folder);
+        if (scope === true) {
+          refreshFolder(folder);
+        } else {
+          refreshFolder(folder, { files: scope });
+        }
       } else {
         deleteCachedFolder(folder);
       }
@@ -1329,6 +1506,20 @@ function startProjectsWatcher() {
     }
   }
 
+  function recordChange(folder, relPath) {
+    const existing = pendingChanges.get(folder);
+    if (existing === true) return;
+    if (relPath === null) {
+      pendingChanges.set(folder, true);
+      return;
+    }
+    if (existing instanceof Set) {
+      existing.add(relPath);
+    } else {
+      pendingChanges.set(folder, new Set([relPath]));
+    }
+  }
+
   try {
     projectsWatcher = fs.watch(PROJECTS_DIR, { recursive: true }, (_eventType, filename) => {
       if (!filename) return;
@@ -1338,12 +1529,14 @@ function startProjectsWatcher() {
       const folder = parts[0];
       if (!folder || folder === '.git') return;
 
-      // Only care about .jsonl changes or top-level folder add/remove
       const basename = parts[parts.length - 1];
       if (parts.length === 1) {
-        pendingFolders.add(folder);
+        // Top-level folder add/remove — must re-scan the whole folder
+        recordChange(folder, null);
       } else if (basename.endsWith('.jsonl')) {
-        pendingFolders.add(folder);
+        // Specific .jsonl changed — targeted refresh on just this file
+        const rel = parts.slice(1).join(path.sep);
+        recordChange(folder, rel);
       } else {
         return;
       }
@@ -1378,6 +1571,12 @@ ipcMain.handle('updater-install', () => {
 });
 
 // --- App lifecycle ---
+// Differentiate the dev build from the released binary in the OS task switcher,
+// dock, and About menu by suffixing the app name. No-op in packaged builds.
+if (!app.isPackaged) {
+  app.setName('Switchboard (dev)');
+}
+
 app.whenReady().then(() => {
   buildMenu();
   createWindow();
diff --git a/package-lock.json b/package-lock.json
index 1695a57..4da2071 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -38,9 +38,77 @@
         "electron-builder": "^26.0.0",
         "electron-reloader": "^1.2.3",
         "esbuild": "^0.27.3",
+        "eslint": "^9.39.4",
+        "globals": "^17.6.0",
+        "husky": "^9.1.7",
+        "jsdom": "^29.1.1",
         "png2icons": "^2.0.1"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+      "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@csstools/css-calc": "^3.2.0",
+        "@csstools/css-color-parser": "^4.1.0",
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+      "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/generational-cache": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+      "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@bramus/specificity": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+      "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "^3.0.0"
+      },
+      "bin": {
+        "specificity": "bin/cli.js"
+      }
+    },
     "node_modules/@codemirror/autocomplete": {
       "version": "6.20.1",
       "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.1.tgz",
@@ -483,6 +551,146 @@
         "w3c-keyname": "^2.2.4"
       }
     },
+    "node_modules/@csstools/color-helpers": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
+      "integrity": "sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.2.1.tgz",
+      "integrity": "sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.1.tgz",
+      "integrity": "sha512-eZ5XOtyhK+mggRafYUWzA0tvaYOFgdY8AkgQiCJF9qNAePnUo/zmsqqYubBBb3sQ8uNUaSKTY9s9klfRaAXL0g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^6.0.2",
+        "@csstools/css-calc": "^3.2.1"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.4.tgz",
+      "integrity": "sha512-wgsqt92b7C7tQhIdPNxj0n9zuUbQlvAuI1exyzeNrOKOi62SD7ren8zqszmpVREjAOqg8cD2FqYhQfAuKjk4sw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+      "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
     "node_modules/@ddietr/codemirror-themes": {
       "version": "1.5.2",
       "resolved": "https://registry.npmjs.org/@ddietr/codemirror-themes/-/codemirror-themes-1.5.2.tgz",
@@ -639,31 +847,6 @@
         "global-agent": "^3.0.0"
       }
     },
-    "node_modules/@electron/get/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@electron/get/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@electron/get/node_modules/semver": {
       "version": "6.3.1",
       "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
@@ -689,24 +872,6 @@
         "node": ">= 10.0.0"
       }
     },
-    "node_modules/@electron/notarize/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@electron/notarize/node_modules/fs-extra": {
       "version": "9.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
@@ -736,13 +901,6 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/@electron/notarize/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@electron/notarize/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -775,24 +933,6 @@
         "node": ">=12.0.0"
       }
     },
-    "node_modules/@electron/osx-sign/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@electron/osx-sign/node_modules/fs-extra": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
@@ -834,13 +974,6 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/@electron/osx-sign/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@electron/osx-sign/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -879,31 +1012,6 @@
         "node": ">=22.12.0"
       }
     },
-    "node_modules/@electron/rebuild/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@electron/rebuild/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@electron/rebuild/node_modules/node-abi": {
       "version": "4.28.0",
       "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-4.28.0.tgz",
@@ -953,24 +1061,6 @@
         "balanced-match": "^1.0.0"
       }
     },
-    "node_modules/@electron/universal/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@electron/universal/node_modules/fs-extra": {
       "version": "11.3.4",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
@@ -1015,13 +1105,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/@electron/universal/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@electron/universal/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -1054,26 +1137,6 @@
         "node": ">=14.14"
       }
     },
-    "node_modules/@electron/windows-sign/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@electron/windows-sign/node_modules/fs-extra": {
       "version": "11.3.4",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
@@ -1106,15 +1169,6 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/@electron/windows-sign/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "peer": true
-    },
     "node_modules/@electron/windows-sign/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -1509,64 +1563,380 @@
         "x64"
       ],
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
+      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
+      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
+      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
+      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.5"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-array/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
+      "version": "1.1.14",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@eslint/config-array/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.5",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
+      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.14.0",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.5",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
+      "version": "1.1.14",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
+      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@exodus/bytes": {
+      "version": "1.15.1",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+      "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
+      "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/types": "^0.15.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.8",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz",
+      "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.2",
+        "@humanfs/types": "^0.15.0",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
       "engines": {
-        "node": ">=18"
+        "node": ">=18.18.0"
       }
     },
-    "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
-      "cpu": [
-        "arm64"
-      ],
+    "node_modules/@humanfs/types": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz",
+      "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=18"
+        "node": ">=18.18.0"
       }
     },
-    "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
-      "cpu": [
-        "ia32"
-      ],
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=18"
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
       }
     },
-    "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
-      "cpu": [
-        "x64"
-      ],
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
       "dev": true,
-      "license": "MIT",
-      "optional": true,
-      "os": [
-        "win32"
-      ],
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=18"
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
       }
     },
     "node_modules/@isaacs/cliui": {
@@ -1918,24 +2288,6 @@
         "node": ">= 10.0.0"
       }
     },
-    "node_modules/@malept/flatpak-bundler/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": {
       "version": "9.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
@@ -1965,13 +2317,6 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/@malept/flatpak-bundler/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@malept/flatpak-bundler/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -2347,6 +2692,13 @@
         "@types/ms": "*"
       }
     },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/fs-extra": {
       "version": "9.0.13",
       "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",
@@ -2364,6 +2716,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/keyv": {
       "version": "3.1.4",
       "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",
@@ -2498,6 +2857,29 @@
         "node": "^18.17.0 || >=20.5.0"
       }
     },
+    "node_modules/acorn": {
+      "version": "8.16.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz",
+      "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
     "node_modules/agent-base": {
       "version": "7.1.4",
       "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
@@ -2697,24 +3079,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/app-builder-lib/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/app-builder-lib/node_modules/fs-extra": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
@@ -2753,13 +3117,6 @@
         "node": ">= 10.0.0"
       }
     },
-    "node_modules/app-builder-lib/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
@@ -2866,6 +3223,16 @@
         "node": "20.x || 22.x || 23.x || 24.x || 25.x"
       }
     },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
@@ -3013,47 +3380,6 @@
         "node": ">=12.0.0"
       }
     },
-    "node_modules/builder-util-runtime/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/builder-util-runtime/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "license": "MIT"
-    },
-    "node_modules/builder-util/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/builder-util/node_modules/fs-extra": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
@@ -3082,13 +3408,6 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/builder-util/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/builder-util/node_modules/universalify": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
@@ -3228,6 +3547,16 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -3540,6 +3869,34 @@
         "node": ">= 8"
       }
     },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/data-urls": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/date-time": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/date-time/-/date-time-3.1.0.tgz",
@@ -3553,6 +3910,30 @@
         "node": ">=6"
       }
     },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/decompress-response": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
@@ -3577,6 +3958,13 @@
         "node": ">=4.0.0"
       }
     },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/defaults": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz",
@@ -4139,25 +4527,6 @@
         "@electron/windows-sign": "^1.1.2"
       }
     },
-    "node_modules/electron-winstaller/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true,
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
     "node_modules/electron-winstaller/node_modules/fs-extra": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
@@ -4174,14 +4543,6 @@
         "node": ">=6 <7 || >=8"
       }
     },
-    "node_modules/electron-winstaller/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT",
-      "peer": true
-    },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
@@ -4223,6 +4584,19 @@
         "once": "^1.4.0"
       }
     },
+    "node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/env-paths": {
       "version": "2.2.1",
       "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
@@ -4355,7 +4729,6 @@
       "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "engines": {
         "node": ">=10"
       },
@@ -4363,6 +4736,204 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/eslint": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
+      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.2",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.5",
+        "@eslint/js": "9.39.4",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.5",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/eslint/node_modules/brace-expansion": {
+      "version": "1.1.14",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.14.tgz",
+      "integrity": "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/eslint/node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/eslint/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/expand-template": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
@@ -4400,31 +4971,6 @@
         "@types/yauzl": "^2.9.1"
       }
     },
-    "node_modules/extract-zip/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/extract-zip/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/extsprintf": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz",
@@ -4450,6 +4996,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/fd-slicer": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
@@ -4460,6 +5013,19 @@
         "pend": "~1.2.0"
       }
     },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/file-uri-to-path": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
@@ -4536,6 +5102,27 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+      "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/foreground-child": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
@@ -4805,6 +5392,19 @@
         "node": ">=10.0"
       }
     },
+    "node_modules/globals": {
+      "version": "17.6.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-17.6.0.tgz",
+      "integrity": "sha512-sepffkT8stwnIYbsMBpoCHJuJM5l98FUF2AnE07hfvE0m/qp3R586hw4jF4uadbhvg1ooIdzuu7CsfD2jzCaNA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/globalthis": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
@@ -4947,6 +5547,19 @@
         "node": ">=10"
       }
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.6.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/http-cache-semantics": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
@@ -4968,31 +5581,6 @@
         "node": ">= 14"
       }
     },
-    "node_modules/http-proxy-agent/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/http-proxy-agent/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/http2-wrapper": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz",
@@ -5021,31 +5609,22 @@
         "node": ">= 14"
       }
     },
-    "node_modules/https-proxy-agent/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+    "node_modules/husky": {
+      "version": "9.1.7",
+      "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz",
+      "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
+      "bin": {
+        "husky": "bin.js"
       },
       "engines": {
-        "node": ">=6.0"
+        "node": ">=18"
       },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
+      "funding": {
+        "url": "https://github.com/sponsors/typicode"
       }
     },
-    "node_modules/https-proxy-agent/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/iconv-corefoundation": {
       "version": "1.1.7",
       "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",
@@ -5092,6 +5671,33 @@
       ],
       "license": "BSD-3-Clause"
     },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/imurmurhash": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
@@ -5202,6 +5808,13 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/is-unicode-supported": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
@@ -5282,16 +5895,67 @@
         "jiti": "lib/jiti-cli.mjs"
       }
     },
-    "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
-      "license": "MIT",
-      "dependencies": {
-        "argparse": "^2.0.1"
-      },
-      "bin": {
-        "js-yaml": "bin/js-yaml.js"
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsdom": {
+      "version": "29.1.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+      "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^5.1.11",
+        "@asamuzakjp/dom-selector": "^7.1.1",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.3.5",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.25.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.5.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.0.tgz",
+      "integrity": "sha512-5YgH9UJd7wVb9hIouI2adWpgqrrICkt070Dnj8EUY1+B4B2P9eRLPAkAAo6NICA7CEhOIeBHl46u9zSNpNu7zA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
       }
     },
     "node_modules/json-buffer": {
@@ -5308,6 +5972,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/json-stringify-safe": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
@@ -5355,6 +6026,20 @@
       "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
       "license": "MIT"
     },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -5391,6 +6076,13 @@
       "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
       "license": "MIT"
     },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/log-symbols": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
@@ -5500,6 +6192,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -5728,12 +6427,25 @@
       "integrity": "sha512-D/fR4xgGUyVRbdMGU6Nejea1RFzYxYtyurG4Fbv2Fi/daKlWKuXGLOdXtl+3eIwL110cI2hz1ZojGICjjFLgTg==",
       "license": "MIT"
     },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
     "node_modules/napi-build-utils": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
       "integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==",
       "license": "MIT"
     },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/node-abi": {
       "version": "3.87.0",
       "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.87.0.tgz",
@@ -5872,6 +6584,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/ora": {
       "version": "5.4.1",
       "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz",
@@ -5958,6 +6688,32 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^8.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -6136,6 +6892,16 @@
         "node": ">=10"
       }
     },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/proc-log": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-5.0.0.tgz",
@@ -6243,31 +7009,6 @@
         "read-binary-file-arch": "cli.js"
       }
     },
-    "node_modules/read-binary-file-arch/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/read-binary-file-arch/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/readable-stream": {
       "version": "3.6.2",
       "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
@@ -6305,6 +7046,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resedit": {
       "version": "1.7.2",
       "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz",
@@ -6330,6 +7081,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/responselike": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",
@@ -6447,6 +7208,19 @@
         "node": ">=11.0.0"
       }
     },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/semver": {
       "version": "7.7.4",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
@@ -6629,31 +7403,6 @@
         "node": ">= 14"
       }
     },
-    "node_modules/socks-proxy-agent/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/socks-proxy-agent/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/source-map": {
       "version": "0.6.1",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
@@ -6664,6 +7413,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/source-map-support": {
       "version": "0.5.21",
       "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
@@ -6802,31 +7561,6 @@
         "node": ">= 8.0"
       }
     },
-    "node_modules/sumchecker/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/sumchecker/node_modules/ms": {
-      "version": "2.1.3",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/supports-color": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
@@ -6840,6 +7574,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tar": {
       "version": "7.5.13",
       "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.13.tgz",
@@ -7053,6 +7794,26 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/tldts": {
+      "version": "7.0.30",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.30.tgz",
+      "integrity": "sha512-ELrFxuqsDdHUwoh0XxDbxuLD3Wnz49Z57IFvTtvWy1hJdcMZjXLIuonjilCiWHlT2GbE4Wlv1wKVTzDFnXH1aw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.0.30"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.0.30",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.30.tgz",
+      "integrity": "sha512-uiHN8PIB1VmWyS98eZYja4xzlYqeFZVjb4OuYlJQnZAuJhMw4PbKQOKgHKhBdJR3FE/t5mUQ1Kd80++B+qhD1Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tmp": {
       "version": "0.2.5",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
@@ -7086,6 +7847,32 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/tough-cookie": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.1.tgz",
+      "integrity": "sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/truncate-utf8-bytes": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
@@ -7108,6 +7895,19 @@
         "node": "*"
       }
     },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/type-fest": {
       "version": "0.13.1",
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
@@ -7122,6 +7922,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/undici": {
+      "version": "7.25.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.25.0.tgz",
+      "integrity": "sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
     "node_modules/undici-types": {
       "version": "7.16.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
@@ -7211,6 +8021,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/wcwidth": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
@@ -7221,6 +8044,41 @@
         "defaults": "^1.0.3"
       }
     },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.11.0",
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz",
@@ -7237,6 +8095,16 @@
         "node": "^18.17.0 || >=20.5.0"
       }
     },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/wrap-ansi": {
       "version": "7.0.0",
       "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
@@ -7301,6 +8169,16 @@
         }
       }
     },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/xmlbuilder": {
       "version": "15.1.1",
       "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
@@ -7311,6 +8189,13 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
diff --git a/package.json b/package.json
index 927c7a4..4ab3fd2 100644
--- a/package.json
+++ b/package.json
@@ -7,6 +7,8 @@
   "main": "main.js",
   "scripts": {
     "start": "npm run bundle:codemirror && electron .",
+    "lint": "eslint .",
+    "pretest": "npm run lint",
     "test": "node --test",
     "electron": "electron .",
     "bundle:codemirror": "esbuild public/codemirror-setup.js --bundle --outfile=public/codemirror-bundle.js --format=iife --platform=browser --minify",
@@ -17,7 +19,8 @@
     "build:win": "npm run bundle:codemirror && electron-builder --win",
     "build:linux": "npm run bundle:codemirror && electron-builder --linux",
     "release": "npm run bundle:codemirror && electron-builder --publish always",
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/postinstall.js",
+    "prepare": "husky"
   },
   "dependencies": {
     "@xterm/addon-fit": "^0.11.0",
@@ -49,6 +52,10 @@
     "electron-builder": "^26.0.0",
     "electron-reloader": "^1.2.3",
     "esbuild": "^0.27.3",
+    "eslint": "^9.39.4",
+    "globals": "^17.6.0",
+    "husky": "^9.1.7",
+    "jsdom": "^29.1.1",
     "png2icons": "^2.0.1"
   },
   "build": {
diff --git a/preload.js b/preload.js
index 91d8b5e..db71964 100644
--- a/preload.js
+++ b/preload.js
@@ -6,12 +6,14 @@ contextBridge.exposeInMainWorld('api', {
   readPlan: (filename) => ipcRenderer.invoke('read-plan', filename),
   savePlan: (filePath, content) => ipcRenderer.invoke('save-plan', filePath, content),
   getStats: () => ipcRenderer.invoke('get-stats'),
+  getStatsFromDb: () => ipcRenderer.invoke('get-stats-from-db'),
   refreshStats: () => ipcRenderer.invoke('refresh-stats'),
   getUsage: () => ipcRenderer.invoke('get-usage'),
   getMemories: () => ipcRenderer.invoke('get-memories'),
   readMemory: (filePath) => ipcRenderer.invoke('read-memory', filePath),
   saveMemory: (filePath, content) => ipcRenderer.invoke('save-memory', filePath, content),
   getProjects: (showArchived) => ipcRenderer.invoke('get-projects', showArchived),
+  rebuildCache: () => ipcRenderer.invoke('rebuild-cache'),
   getActiveSessions: () => ipcRenderer.invoke('get-active-sessions'),
   getActiveTerminals: () => ipcRenderer.invoke('get-active-terminals'),
   stopSession: (id) => ipcRenderer.invoke('stop-session', id),
@@ -21,6 +23,10 @@ contextBridge.exposeInMainWorld('api', {
   openTerminal: (id, projectPath, isNew, sessionOptions) => ipcRenderer.invoke('open-terminal', id, projectPath, isNew, sessionOptions),
   search: (type, query, titleOnly) => ipcRenderer.invoke('search', type, query, titleOnly),
   readSessionJsonl: (sessionId) => ipcRenderer.invoke('read-session-jsonl', sessionId),
+  readSubagentJsonl: (parentSessionId, agentId) => ipcRenderer.invoke('read-subagent-jsonl', parentSessionId, agentId),
+  listSubagents: (parentSessionId) => ipcRenderer.invoke('list-subagents', parentSessionId),
+  startSubagentWatch: (parentSessionId, agentId) => ipcRenderer.invoke('start-subagent-watch', parentSessionId, agentId),
+  stopSubagentWatch: (watchId) => ipcRenderer.invoke('stop-subagent-watch', watchId),
 
   // Settings
   getSetting: (key) => ipcRenderer.invoke('get-setting', key),
@@ -35,6 +41,7 @@ contextBridge.exposeInMainWorld('api', {
   browseFolder: () => ipcRenderer.invoke('browse-folder'),
   addProject: (projectPath) => ipcRenderer.invoke('add-project', projectPath),
   removeProject: (projectPath) => ipcRenderer.invoke('remove-project', projectPath),
+  deleteWorktree: (worktreePath) => ipcRenderer.invoke('delete-worktree', worktreePath),
   openExternal: (url) => ipcRenderer.invoke('open-external', url),
 
   // Send (fire-and-forget)
@@ -61,6 +68,9 @@ contextBridge.exposeInMainWorld('api', {
   onSessionForked: (callback) => {
     ipcRenderer.on('session-forked', (_event, oldId, newId) => callback(oldId, newId));
   },
+  onSubagentSpawned: (cb) => ipcRenderer.on('subagent-spawned', (_e, payload) => cb(payload)),
+  onSubagentCompleted: (cb) => ipcRenderer.on('subagent-completed', (_e, payload) => cb(payload)),
+  onSubagentWatchEvent: (cb) => ipcRenderer.on('subagent-watch-event', (_e, payload) => cb(payload)),
   onProjectsChanged: (callback) => {
     ipcRenderer.on('projects-changed', () => callback());
   },
diff --git a/public/app.js b/public/app.js
index 9ab01b8..caa40c2 100644
--- a/public/app.js
+++ b/public/app.js
@@ -461,56 +461,92 @@ searchClear.addEventListener('click', () => {
   searchInput.focus();
 });
 
+// Extracted so the rebuild-cache button and Enter handler can call it too.
+async function runSearchQuery() {
+  const query = searchInput.value.trim();
+  if (!query) {
+    clearSearch();
+    return;
+  }
+  try {
+    if (activeTab === 'sessions') {
+      const results = await window.api.search('session', query, searchTitlesOnly);
+      searchMatchIds = new Set(results.map(r => r.id));
+      searchMatchProjectPaths = null;
+      if (searchTitlesOnly) {
+        const lowerQ = query.toLowerCase();
+        for (const p of cachedAllProjects) {
+          const shortName = p.projectPath.split('/').filter(Boolean).slice(-2).join('/');
+          if (shortName.toLowerCase().includes(lowerQ)) {
+            if (!searchMatchProjectPaths) searchMatchProjectPaths = new Set();
+            searchMatchProjectPaths.add(p.projectPath);
+          }
+        }
+      }
+      refreshSidebar({ resort: true });
+    } else if (activeTab === 'plans') {
+      const results = await window.api.search('plan', query, searchTitlesOnly);
+      const matchIds = new Set(results.map(r => r.id));
+      renderPlans(cachedPlans.filter(p => matchIds.has(p.filename)));
+    } else if (activeTab === 'memory') {
+      const results = await window.api.search('memory', query, searchTitlesOnly);
+      const matchIds = new Set(results.map(r => r.id));
+      renderMemories(matchIds);
+    }
+  } catch {
+    if (activeTab === 'sessions') {
+      searchMatchIds = null;
+      searchMatchProjectPaths = null;
+      refreshSidebar({ resort: true });
+    }
+  }
+}
+
+// Debounced search-as-you-type. Bumped from 200ms to 350ms — gentler under
+// heavy workloads (many active subagents) and gives the user time to finish
+// a word before searching. Explicit triggers (Enter, refresh button) bypass
+// the debounce.
 searchInput.addEventListener('input', () => {
-  // Toggle clear button visibility
   searchBar.classList.toggle('has-query', searchInput.value.length > 0);
-
   if (searchDebounceTimer) clearTimeout(searchDebounceTimer);
-  searchDebounceTimer = setTimeout(async () => {
+  searchDebounceTimer = setTimeout(() => {
     searchDebounceTimer = null;
-    const query = searchInput.value.trim();
-
-    if (!query) {
-      clearSearch();
-      return;
-    }
+    runSearchQuery();
+  }, 350);
+});
 
-    try {
-      if (activeTab === 'sessions') {
-        const results = await window.api.search('session', query, searchTitlesOnly);
-        searchMatchIds = new Set(results.map(r => r.id));
-        // When title-only, also match project names
-        searchMatchProjectPaths = null;
-        if (searchTitlesOnly) {
-          const lowerQ = query.toLowerCase();
-          for (const p of cachedAllProjects) {
-            const shortName = p.projectPath.split('/').filter(Boolean).slice(-2).join('/');
-            if (shortName.toLowerCase().includes(lowerQ)) {
-              if (!searchMatchProjectPaths) searchMatchProjectPaths = new Set();
-              searchMatchProjectPaths.add(p.projectPath);
-            }
-          }
-        }
-        refreshSidebar({ resort: true });
-      } else if (activeTab === 'plans') {
-        const results = await window.api.search('plan', query, searchTitlesOnly);
-        const matchIds = new Set(results.map(r => r.id));
-        renderPlans(cachedPlans.filter(p => matchIds.has(p.filename)));
-      } else if (activeTab === 'memory') {
-        const results = await window.api.search('memory', query, searchTitlesOnly);
-        const matchIds = new Set(results.map(r => r.id));
-        renderMemories(matchIds);
-      }
-    } catch {
-      if (activeTab === 'sessions') {
-        searchMatchIds = null;
-        searchMatchProjectPaths = null;
-        refreshSidebar({ resort: true });
-      }
-    }
-  }, 200);
+// Enter in the search field = "I want fresh results": trigger a full worker
+// reindex (which rewrites search_fts with the live content of active session
+// JSONLs), then re-run the query. Pending debounce gets cancelled.
+searchInput.addEventListener('keydown', async (e) => {
+  if (e.key !== 'Enter') return;
+  e.preventDefault();
+  if (searchDebounceTimer) { clearTimeout(searchDebounceTimer); searchDebounceTimer = null; }
+  await triggerRebuildAndSearch();
 });
 
+// Refresh button in the search bar — same behavior as pressing Enter.
+const searchRefreshBtn = document.getElementById('search-refresh-btn');
+if (searchRefreshBtn) {
+  searchRefreshBtn.addEventListener('click', () => triggerRebuildAndSearch());
+}
+
+let rebuildInFlight = false;
+async function triggerRebuildAndSearch() {
+  if (rebuildInFlight) return;
+  rebuildInFlight = true;
+  if (searchRefreshBtn) searchRefreshBtn.classList.add('spinning');
+  try {
+    await window.api.rebuildCache();
+  } catch {}
+  finally {
+    rebuildInFlight = false;
+    if (searchRefreshBtn) searchRefreshBtn.classList.remove('spinning');
+  }
+  // After reindex, refire the current query so the user sees fresh hits.
+  await runSearchQuery();
+}
+
 // --- Stop session helper ---
 async function confirmAndStopSession(sessionId) {
   if (!confirm('Stop this session?')) return;
@@ -1047,10 +1083,13 @@ window.api.onProjectsChanged(() => {
     projectsChangedWhileAway = true;
     return;
   }
+  // 300ms debounce was visibly flickering while live JSONLs trigger watcher
+  // flushes every ~500ms; with the main-side notify throttle (1.5s) too the
+  // sidebar redraws at most ~1×/sec.
   projectsChangedTimer = setTimeout(() => {
     projectsChangedTimer = null;
     loadProjects();
-  }, 300);
+  }, 900);
 });
 
 // Status bar
diff --git a/public/grid-view.js b/public/grid-view.js
index 56eea95..f7b7622 100644
--- a/public/grid-view.js
+++ b/public/grid-view.js
@@ -11,6 +11,111 @@
 let gridCards = new Map(); // sessionId → card wrapper element
 let gridFocusedSessionId = null;
 
+// Active subagents tracked via IPC events (subagent-spawned / subagent-completed).
+// parentSessionId → Set of { agentId, subagentType, spawnedAt }
+const activeSubagents = new Map();
+
+// Subagent type → pill color (matches sidebar palette)
+const GRID_SUBAGENT_TYPE_COLORS = {
+  explore:   '#3ecf82',
+  plan:      '#8088ff',
+  implement: '#ffaa40',
+  review:    '#60bef0',
+  test:      '#ff6464',
+  default:   '#a0a0b4',
+};
+
+function gridSubagentColor(type) {
+  return GRID_SUBAGENT_TYPE_COLORS[(type || '').toLowerCase()] || GRID_SUBAGENT_TYPE_COLORS.default;
+}
+
+// Wire IPC listeners (guarded — bindings may not exist yet)
+(function initSubagentListeners() {
+  if (typeof window.api === 'undefined') return;
+
+  if (typeof window.api.onSubagentSpawned === 'function') {
+    window.api.onSubagentSpawned((event, data) => {
+      const { parentSessionId, agentId, subagentType } = data || {};
+      if (!parentSessionId || !agentId) return;
+      if (!activeSubagents.has(parentSessionId)) activeSubagents.set(parentSessionId, new Map());
+      activeSubagents.get(parentSessionId).set(agentId, { agentId, subagentType, spawnedAt: Date.now() });
+      updateGridSubagentPills(parentSessionId);
+    });
+  }
+
+  if (typeof window.api.onSubagentCompleted === 'function') {
+    window.api.onSubagentCompleted((event, data) => {
+      const { parentSessionId, agentId } = data || {};
+      if (!parentSessionId || !agentId) return;
+      const map = activeSubagents.get(parentSessionId);
+      if (map) {
+        map.delete(agentId);
+        if (map.size === 0) activeSubagents.delete(parentSessionId);
+      }
+      updateGridSubagentPills(parentSessionId);
+    });
+  }
+})();
+
+// Prune subagents that have been running for more than 60 s without a completion event.
+// Called on each grid render cycle.
+function pruneStaleSubagents() {
+  const cutoff = Date.now() - 60000;
+  for (const [parentId, map] of activeSubagents) {
+    for (const [agentId, info] of map) {
+      if (info.spawnedAt < cutoff) map.delete(agentId);
+    }
+    if (map.size === 0) activeSubagents.delete(parentId);
+  }
+}
+
+// Re-render the pill row for a single card (if it exists in the grid).
+function updateGridSubagentPills(parentSessionId) {
+  const card = gridCards.get(parentSessionId);
+  if (!card) return;
+
+  let pillRow = card.querySelector('.grid-subagent-pills');
+
+  const map = activeSubagents.get(parentSessionId);
+  if (!map || map.size === 0) {
+    if (pillRow) pillRow.remove();
+    return;
+  }
+
+  if (!pillRow) {
+    pillRow = document.createElement('div');
+    pillRow.className = 'grid-subagent-pills';
+    // Insert before the footer
+    const footer = card.querySelector('.grid-card-footer');
+    if (footer) {
+      card.insertBefore(pillRow, footer);
+    } else {
+      card.appendChild(pillRow);
+    }
+  }
+
+  pillRow.innerHTML = '';
+  const entries = [...map.values()];
+  const MAX_PILLS = 5;
+  const shown = entries.slice(0, MAX_PILLS);
+  const overflow = entries.length - shown.length;
+
+  for (const info of shown) {
+    const pill = document.createElement('span');
+    pill.className = 'grid-subagent-pill';
+    pill.title = info.subagentType || 'subagent';
+    pill.style.background = gridSubagentColor(info.subagentType);
+    pillRow.appendChild(pill);
+  }
+
+  if (overflow > 0) {
+    const more = document.createElement('span');
+    more.className = 'grid-subagent-pill-overflow';
+    more.textContent = `+${overflow} more`;
+    pillRow.appendChild(more);
+  }
+}
+
 function wrapInGridCard(sessionId) {
   const entry = openSessions.get(sessionId);
   const session = sessionMap.get(sessionId) || (entry && entry.session);
@@ -132,6 +237,10 @@ function wrapInGridCard(sessionId) {
   gridCards.set(sessionId, card);
   // Set initial status from the single source of truth
   updateRunningIndicators();
+
+  // Render subagent pills for any already-tracked children
+  pruneStaleSubagents();
+  updateGridSubagentPills(sessionId);
 }
 
 function unwrapGridCards() {
diff --git a/public/index.html b/public/index.html
index 8484857..6415556 100644
--- a/public/index.html
+++ b/public/index.html
@@ -34,6 +34,7 @@
       <input id="search-input" type="text" placeholder="Search sessions..." />
       <button id="search-clear" type="button" aria-label="Clear search">&times;</button>
       <button id="search-titles-toggle" type="button" title="Search titles only" aria-label="Search titles only">Tt</button>
+      <button id="search-refresh-btn" type="button" title="Reindex all sessions (full reread for search). Enter in the search field triggers the same."><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12a9 9 0 1 1-3-6.7L21 8"/><path d="M21 3v5h-5"/></svg></button>
     </div>
     <div id="sidebar-content"></div>
     <div id="plans-content" style="display:none;"></div>
diff --git a/public/jsonl-viewer.js b/public/jsonl-viewer.js
index 9c28bab..2c1a2bc 100644
--- a/public/jsonl-viewer.js
+++ b/public/jsonl-viewer.js
@@ -2,6 +2,40 @@
 // Depends on globals: escapeHtml (utils.js), hideAllViewers, placeholder,
 // terminalArea, jsonlViewer, jsonlViewerTitle, jsonlViewerSessionId, jsonlViewerBody (app.js)
 
+// Current viewer session — set once per showJsonlViewer call, read by Agent renderer
+let currentViewerSessionId = null;
+// Counter for matching identical (description, subagentType) blocks in fanout scenarios
+// Reset on each showJsonlViewer call. Key: "<contextSessionId>|<desc>|<type>"
+let agentMatchCounters = {};
+
+// --- Live subagent tracking ---
+// Set of agentIds that are currently live (spawned but not yet completed).
+// Keyed as "<parentSessionId>:<agentId>" so it's globally unique.
+const liveSubagents = new Set();
+
+// Register IPC listeners for subagent lifecycle events (called once at module load).
+(function initSubagentListeners() {
+  if (!window.api) return; // guard for non-Electron contexts
+  window.api.onSubagentSpawned((payload) => {
+    const key = payload.parentSessionId + ':' + payload.agentId;
+    liveSubagents.add(key);
+  });
+  window.api.onSubagentCompleted((payload) => {
+    const key = payload.parentSessionId + ':' + payload.agentId;
+    liveSubagents.delete(key);
+    // Notify any active watch container so it can stop the watch and hide the indicator
+    document.querySelectorAll('[data-subagent-watch-key="' + key + '"]').forEach(el => {
+      el.dispatchEvent(new CustomEvent('subagent-completed-internal'));
+    });
+  });
+  window.api.onSubagentWatchEvent((payload) => {
+    const key = payload.parentSessionId + ':' + payload.agentId;
+    document.querySelectorAll('[data-subagent-watch-key="' + key + '"]').forEach(el => {
+      el.dispatchEvent(new CustomEvent('subagent-watch-data', { detail: payload }));
+    });
+  });
+})()
+
 function renderJsonlText(text) {
   if (window.marked) {
     // Escape XML/HTML-like tags so they render as visible text,
@@ -211,12 +245,143 @@ const toolRenderers = {
     return toolBlock('#c090e0', 'Glob', '<code>' + escapeHtml(pattern) + '</code>', null);
   },
 
-  Agent(input) {
+  Agent(input, block) {
     const desc = input.description || '';
     const type = input.subagent_type || '';
-    const summary = (type ? '<span class="jsonl-tool-detail">' + escapeHtml(type) + '</span> ' : '')
+    const caretSpan = '<span class="jsonl-agent-caret">&#9658;</span> ';
+    const summary = caretSpan
+      + (type ? '<span class="jsonl-tool-detail">' + escapeHtml(type) + '</span> ' : '')
       + escapeHtml(desc);
-    return toolBlock('#f0a050', 'Agent', summary, null);
+    const el = toolBlock('#f0a050', 'Agent', summary, null);
+    el.classList.add('jsonl-agent-expandable');
+    // Capture context at render time
+    const parentSessionId = currentViewerSessionId;
+    if (!parentSessionId) return el;
+
+    // Determine which Nth match this block is for fanout deduplication
+    const counterKey = parentSessionId + '|' + desc + '|' + type;
+    if (agentMatchCounters[counterKey] === undefined) agentMatchCounters[counterKey] = 0;
+    const matchIndex = agentMatchCounters[counterKey]++;
+
+    let expanded = false;
+    let nestedContainer = null;
+    let activeWatchId = null;
+    let liveIndicator = null;
+
+    function stopWatch() {
+      if (activeWatchId !== null) {
+        window.api.stopSubagentWatch(activeWatchId).catch(() => {});
+        activeWatchId = null;
+      }
+      if (liveIndicator) {
+        liveIndicator.remove();
+        liveIndicator = null;
+      }
+    }
+
+    el.addEventListener('click', async () => {
+      if (expanded && nestedContainer) {
+        // Collapse — stop live watch
+        stopWatch();
+        nestedContainer.remove();
+        nestedContainer = null;
+        expanded = false;
+        const caret = el.querySelector('.jsonl-agent-caret');
+        if (caret) caret.innerHTML = '&#9658;';
+        return;
+      }
+      // Fetch subagent list for this parent
+      const subagents = await window.api.listSubagents(parentSessionId);
+      const matches = subagents.filter(s =>
+        (s.description || '') === desc && (s.subagentType || '') === type
+      );
+      const match = matches[matchIndex] || matches[0];
+      if (!match) return;
+
+      const result = await window.api.readSubagentJsonl(parentSessionId, match.agentId);
+      if (result.error || !result.entries) return;
+
+      nestedContainer = document.createElement('div');
+      nestedContainer.className = 'jsonl-subagent-nested';
+
+      const subSessionId = match.sessionId;
+      const rawNested = result.entries;
+      const nestedEntries = mergeLocalCommandEntries(rawNested);
+
+      // Build tool result map for nested entries
+      const nestedResultMap = new Map();
+      for (const entry of nestedEntries) {
+        const blocks = entry.message?.content || entry.content;
+        if (!Array.isArray(blocks)) continue;
+        for (const b of blocks) {
+          if (b.type === 'tool_result' && b.tool_use_id) {
+            nestedResultMap.set(b.tool_use_id, b.content || b.output || '');
+          }
+        }
+      }
+
+      const prevSessionId = currentViewerSessionId;
+      currentViewerSessionId = subSessionId;
+      for (const entry of nestedEntries) {
+        const entryEl = renderJsonlEntry(entry, nestedResultMap);
+        if (entryEl) nestedContainer.appendChild(entryEl);
+      }
+      currentViewerSessionId = prevSessionId;
+
+      el.after(nestedContainer);
+      expanded = true;
+      const caret = el.querySelector('.jsonl-agent-caret');
+      if (caret) caret.innerHTML = '&#9660;';
+
+      // Start live watch if this subagent is still running
+      const watchKey = parentSessionId + ':' + match.agentId;
+      if (liveSubagents.has(watchKey)) {
+        // Attach the watch key to nestedContainer for event routing
+        nestedContainer.dataset.subagentWatchKey = watchKey;
+
+        const watchResult = await window.api.startSubagentWatch(parentSessionId, match.agentId);
+        if (watchResult && watchResult.watchId) {
+          activeWatchId = watchResult.watchId;
+
+          // Show "● live" indicator in the block header
+          liveIndicator = document.createElement('span');
+          liveIndicator.className = 'jsonl-agent-live';
+          liveIndicator.textContent = '● live';
+          const toolHeader = el.querySelector('.jsonl-tool-header');
+          if (toolHeader) toolHeader.appendChild(liveIndicator);
+
+          // Stream new entries into nestedContainer
+          nestedContainer.addEventListener('subagent-watch-data', (evt) => {
+            const { entries: newEntries } = evt.detail;
+            const merged = mergeLocalCommandEntries(newEntries);
+            const appendResultMap = new Map();
+            for (const entry of merged) {
+              const blocks2 = entry.message?.content || entry.content;
+              if (!Array.isArray(blocks2)) continue;
+              for (const b of blocks2) {
+                if (b.type === 'tool_result' && b.tool_use_id) {
+                  appendResultMap.set(b.tool_use_id, b.content || b.output || '');
+                }
+              }
+            }
+            const savedId = currentViewerSessionId;
+            currentViewerSessionId = subSessionId;
+            for (const entry of merged) {
+              const entryEl = renderJsonlEntry(entry, appendResultMap);
+              if (entryEl) nestedContainer.appendChild(entryEl);
+            }
+            currentViewerSessionId = savedId;
+          });
+
+          // Stop watch when subagent completes
+          nestedContainer.addEventListener('subagent-completed-internal', () => {
+            stopWatch();
+          });
+        }
+      }
+    });
+
+    return el;
   },
 };
 
@@ -559,6 +724,10 @@ async function showJsonlViewer(session) {
   terminalArea.style.display = 'none';
   jsonlViewer.style.display = 'flex';
 
+  // Set viewer context for Agent block expansion
+  currentViewerSessionId = session.sessionId;
+  agentMatchCounters = {};
+
   const displayName = session.name || session.aiTitle || session.summary || session.sessionId;
   jsonlViewerTitle.textContent = displayName;
   jsonlViewerSessionId.textContent = session.sessionId;
diff --git a/public/sidebar.js b/public/sidebar.js
index 45985dd..7ca2bc4 100644
--- a/public/sidebar.js
+++ b/public/sidebar.js
@@ -17,6 +17,82 @@ function folderId(projectPath) {
   return 'project-' + projectPath.replace(/[^a-zA-Z0-9_-]/g, '_');
 }
 
+// --- Subagent localStorage helpers ---
+function getExpandedSubagents() {
+  try {
+    return new Set(JSON.parse(localStorage.getItem('expandedSubagents') || '[]'));
+  } catch (e) { return new Set(); }
+}
+
+function saveExpandedSubagents(set) {
+  try {
+    localStorage.setItem('expandedSubagents', JSON.stringify([...set]));
+  } catch (e) {}
+}
+
+// Subagent type → accent color (background / border)
+const SUBAGENT_TYPE_COLORS = {
+  explore:   { bg: 'rgba(62,207,130,0.18)',  border: '#3ecf82' },
+  plan:      { bg: 'rgba(128,136,255,0.20)', border: '#8088ff' },
+  implement: { bg: 'rgba(255,170,64,0.18)',  border: '#ffaa40' },
+  review:    { bg: 'rgba(96,190,240,0.18)',  border: '#60bef0' },
+  test:      { bg: 'rgba(255,100,100,0.18)', border: '#ff6464' },
+  default:   { bg: 'rgba(160,160,180,0.15)', border: '#a0a0b4' },
+};
+
+function subagentTypeColor(type) {
+  const key = (type || '').toLowerCase();
+  return SUBAGENT_TYPE_COLORS[key] || SUBAGENT_TYPE_COLORS.default;
+}
+
+function buildSubagentItem(session) {
+  const item = document.createElement('div');
+  item.className = 'sidebar-subagent session-item';
+  item.id = 'si-' + session.sessionId;
+  if (activePtyIds.has(session.sessionId)) item.classList.add('has-running-pty');
+  if (attentionSessions.has(session.sessionId)) item.classList.add('needs-attention');
+  if (responseReadySessions.has(session.sessionId)) item.classList.add('response-ready');
+  if (sessionBusyState.get(session.sessionId)) item.classList.add('cli-busy');
+  item.dataset.sessionId = session.sessionId;
+  item.dataset.subagent = '1';
+
+  const { bg, border } = subagentTypeColor(session.subagentType);
+  item.style.borderLeftColor = border;
+
+  const row = document.createElement('div');
+  row.className = 'session-row';
+
+  const typePill = document.createElement('span');
+  typePill.className = 'sidebar-subagent-type';
+  typePill.textContent = session.subagentType || 'sub';
+  typePill.style.background = bg;
+  typePill.style.borderColor = border;
+
+  const dot = document.createElement('span');
+  dot.className = 'session-status-dot' + (activePtyIds.has(session.sessionId) ? ' running' : '');
+
+  const info = document.createElement('div');
+  info.className = 'session-info';
+
+  const summaryEl = document.createElement('div');
+  summaryEl.className = 'session-summary';
+  summaryEl.textContent = session.description || session.summary || session.aiTitle || session.sessionId;
+
+  const metaEl = document.createElement('div');
+  metaEl.className = 'session-meta';
+  metaEl.textContent = session.messageCount ? session.messageCount + ' msgs' : '';
+
+  info.appendChild(summaryEl);
+  info.appendChild(metaEl);
+
+  row.appendChild(typePill);
+  row.appendChild(dot);
+  row.appendChild(info);
+  item.appendChild(row);
+
+  return item;
+}
+
 function buildSlugGroup(slug, sessions) {
   const group = document.createElement('div');
   const id = slugId(slug);
@@ -146,10 +222,25 @@ function renderProjects(projects, resort) {
 
   const newSortedOrder = [];
 
+  // Build subagent child index from all sessions in this project: parentSessionId → [sessions]
+  function buildSubagentIndex(sessions) {
+    const index = new Map();
+    for (const s of sessions) {
+      if (s.parentSessionId) {
+        if (!index.has(s.parentSessionId)) index.set(s.parentSessionId, []);
+        index.get(s.parentSessionId).push(s);
+      }
+    }
+    return index;
+  }
+
   // Process a project's sessions: filter, sort, slug-group, order, and truncate.
   // Returns { filtered, visible, older, sortOrderEntry } or null if project should be skipped.
   function processProjectSessions(project, resort) {
-    let filtered = project.sessions;
+    // Separate subagents from top-level sessions
+    const allSessions = project.sessions;
+    const subagentIndex = buildSubagentIndex(allSessions);
+    let filtered = allSessions.filter(s => !s.parentSessionId);
     if (showStarredOnly) filtered = filtered.filter(s => s.starred);
     if (showRunningOnly) filtered = filtered.filter(s => activePtyIds.has(s.sessionId));
     if (showTodayOnly) {
@@ -239,17 +330,61 @@ function renderProjects(projects, resort) {
     }
 
     return {
-      filtered, visible, older,
+      filtered, visible, older, subagentIndex,
       sortOrderEntry: { projectPath: project.projectPath, itemIds: allItems.map(item => item.element.id) },
     };
   }
 
+  // Append subagent children beneath a session item element.
+  function appendSubagentChildren(parentEl, parentSessionId, subagentIndex) {
+    const children = subagentIndex && subagentIndex.get(parentSessionId);
+    if (!children || children.length === 0) return;
+
+    const expandedSet = getExpandedSubagents();
+    const caretId = 'sub-caret-' + parentSessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    const isExpanded = expandedSet.has(parentSessionId);
+
+    // Caret/toggle row attached to parent item
+    const caret = document.createElement('div');
+    caret.className = 'sidebar-children-caret';
+    caret.id = caretId;
+    if (isExpanded) caret.classList.add('expanded');
+    caret.innerHTML = `<span class="caret-arrow">&#9654;</span> ${children.length} subagent${children.length !== 1 ? 's' : ''}`;
+
+    const childrenContainer = document.createElement('div');
+    childrenContainer.className = 'sidebar-subagents-container';
+    childrenContainer.id = 'subc-' + parentSessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    childrenContainer.style.display = isExpanded ? '' : 'none';
+
+    for (const child of children) {
+      childrenContainer.appendChild(buildSubagentItem(child));
+    }
+
+    caret.addEventListener('click', (e) => {
+      e.stopPropagation();
+      const open = childrenContainer.style.display !== 'none';
+      childrenContainer.style.display = open ? 'none' : '';
+      caret.classList.toggle('expanded', !open);
+      const set = getExpandedSubagents();
+      if (open) { set.delete(parentSessionId); } else { set.add(parentSessionId); }
+      saveExpandedSubagents(set);
+    });
+
+    parentEl.after(caret);
+    caret.after(childrenContainer);
+  }
+
   // Build the sessions list DOM (shared between projects and worktrees)
-  function buildSessionsList(fId, visible, older) {
+  function buildSessionsList(fId, visible, older, subagentIndex, projectPath) {
     const sessionsList = document.createElement('div');
     sessionsList.className = 'project-sessions';
     sessionsList.id = 'sessions-' + fId;
-    for (const item of visible) sessionsList.appendChild(item.element);
+    for (const item of visible) {
+      sessionsList.appendChild(item.element);
+      // Attach subagent children for top-level sessions
+      const sid = item.element.dataset && item.element.dataset.sessionId;
+      if (sid) appendSubagentChildren(item.element, sid, subagentIndex);
+    }
     if (older.length > 0) {
       const moreBtn = document.createElement('div');
       moreBtn.className = 'sessions-more-toggle';
@@ -259,10 +394,50 @@ function renderProjects(projects, resort) {
       olderList.className = 'sessions-older';
       olderList.id = 'older-list-' + fId;
       olderList.style.display = 'none';
-      for (const item of older) olderList.appendChild(item.element);
+      for (const item of older) {
+        olderList.appendChild(item.element);
+        const sid = item.element.dataset && item.element.dataset.sessionId;
+        if (sid) appendSubagentChildren(item.element, sid, subagentIndex);
+      }
       sessionsList.appendChild(moreBtn);
       sessionsList.appendChild(olderList);
     }
+
+    // Orphan subagents: children whose parentSessionId has no top-level session in this project
+    if (subagentIndex) {
+      const allTopLevelIds = new Set([...visible, ...older].map(i => i.element.dataset && i.element.dataset.sessionId).filter(Boolean));
+      const orphans = [];
+      for (const [parentId, kids] of subagentIndex) {
+        if (!allTopLevelIds.has(parentId)) {
+          for (const k of kids) orphans.push(k);
+        }
+      }
+      if (orphans.length > 0) {
+        // Persist expand/collapse per project. Default = collapsed: this
+        // section is rarely the user's focus and can grow long on long-lived
+        // projects (this very session has 1300+ orphan subagents).
+        const orphanStateKey = 'orphanExpanded:' + projectPath;
+        const expanded = localStorage.getItem(orphanStateKey) === '1';
+
+        const orphanGroup = document.createElement('div');
+        orphanGroup.className = 'sidebar-orphan-subagents' + (expanded ? '' : ' collapsed');
+
+        const orphanLabel = document.createElement('div');
+        orphanLabel.className = 'sidebar-orphan-label';
+        orphanLabel.innerHTML = `<span class="orphan-caret">&#9656;</span> Orphan subagents <span class="orphan-count">${orphans.length}</span>`;
+        orphanLabel.addEventListener('click', () => {
+          const isCollapsed = orphanGroup.classList.toggle('collapsed');
+          localStorage.setItem(orphanStateKey, isCollapsed ? '0' : '1');
+        });
+        orphanGroup.appendChild(orphanLabel);
+
+        for (const orphan of orphans) {
+          orphanGroup.appendChild(buildSubagentItem(orphan));
+        }
+        sessionsList.appendChild(orphanGroup);
+      }
+    }
+
     return sessionsList;
   }
 
@@ -272,7 +447,7 @@ function renderProjects(projects, resort) {
 
     const result = processProjectSessions(project, resort);
     if (!result) continue;
-    const { filtered, visible, older, sortOrderEntry } = result;
+    const { filtered, visible, older, subagentIndex, sortOrderEntry } = result;
     newSortedOrder.push(sortOrderEntry);
     const fId = folderId(project.projectPath);
 
@@ -311,7 +486,7 @@ function renderProjects(projects, resort) {
     newBtn.title = 'New session';
     header.appendChild(newBtn);
 
-    const sessionsList = buildSessionsList(fId, visible, older);
+    const sessionsList = buildSessionsList(fId, visible, older, subagentIndex, project.projectPath);
 
     // Auto-collapse if most recent session is older than threshold, or project matched with no sessions
     if (project._projectMatchedOnly) {
@@ -351,13 +526,19 @@ function renderProjects(projects, resort) {
       wtHideBtn.innerHTML = '<svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>';
       wtHeader.appendChild(wtHideBtn);
 
+      const wtDeleteBtn = document.createElement('button');
+      wtDeleteBtn.className = 'worktree-delete-btn';
+      wtDeleteBtn.title = 'Delete worktree from disk';
+      wtDeleteBtn.innerHTML = '<svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-1 14a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M9 6V4a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2"/></svg>';
+      wtHeader.appendChild(wtDeleteBtn);
+
       const wtNewBtn = document.createElement('button');
       wtNewBtn.className = 'project-new-btn worktree-new-btn';
       wtNewBtn.innerHTML = '<svg width="10" height="10" viewBox="0 0 12 12" fill="none" stroke="currentColor" stroke-width="1.5"><line x1="6" y1="2" x2="6" y2="10"/><line x1="2" y1="6" x2="10" y2="6"/></svg>';
       wtNewBtn.title = 'New session in worktree';
       wtHeader.appendChild(wtNewBtn);
 
-      const wtSessionsList = buildSessionsList(wtFId, wtResult.visible, wtResult.older);
+      const wtSessionsList = buildSessionsList(wtFId, wtResult.visible, wtResult.older, wtResult.subagentIndex, wt.projectPath);
       wtSessionsList.className = 'worktree-sessions';
 
       // Auto-collapse worktree if stale
@@ -403,6 +584,20 @@ function renderProjects(projects, resort) {
           toEl.classList.remove('collapsed');
         }
       }
+      if (fromEl.classList.contains('sidebar-children-caret')) {
+        if (fromEl.classList.contains('expanded')) {
+          toEl.classList.add('expanded');
+        } else {
+          toEl.classList.remove('expanded');
+        }
+      }
+      if (fromEl.classList.contains('sidebar-subagents-container')) {
+        if (fromEl.style.display !== 'none') {
+          toEl.style.display = '';
+        } else {
+          toEl.style.display = 'none';
+        }
+      }
       if (fromEl.classList.contains('sessions-older') && fromEl.style.display !== 'none') {
         toEl.style.display = '';
       }
@@ -499,8 +694,23 @@ function rebindSidebarEvents(projects) {
         loadProjects();
       };
     }
+    const wtDeleteBtn = wtHeader.querySelector('.worktree-delete-btn');
+    if (wtDeleteBtn) {
+      wtDeleteBtn.onclick = async (e) => {
+        e.stopPropagation();
+        const name = wtProject.projectPath.split('/').pop();
+        if (!confirm(`Delete worktree "${name}" from disk?\n\nThis runs "git worktree remove -f" and permanently removes the working tree. This cannot be undone.`)) return;
+        const result = await window.api.deleteWorktree(wtProject.projectPath);
+        if (result && result.ok) {
+          loadProjects();
+        } else {
+          const msg = (result && result.error) ? result.error : 'Unknown error';
+          alert(`Failed to delete worktree: ${msg}`);
+        }
+      };
+    }
     wtHeader.onclick = (e) => {
-      if (e.target.closest('.worktree-new-btn') || e.target.closest('.worktree-hide-btn')) return;
+      if (e.target.closest('.worktree-new-btn') || e.target.closest('.worktree-hide-btn') || e.target.closest('.worktree-delete-btn')) return;
       wtHeader.classList.toggle('collapsed');
     };
   });
@@ -560,6 +770,9 @@ function rebindSidebarEvents(projects) {
 
     item.onclick = () => openSession(session);
 
+    // Subagent items are read-only: skip pin, rename, stop, fork, archive, jsonl, launchConfig
+    if (item.dataset.subagent) return;
+
     const pin = item.querySelector('.session-pin');
     if (pin) {
       pin.onclick = async (e) => {
diff --git a/public/stats-view.js b/public/stats-view.js
index 11e04b6..0b5608e 100644
--- a/public/stats-view.js
+++ b/public/stats-view.js
@@ -6,13 +6,14 @@ let cachedUsage = null;
 async function loadStats() {
   statsViewerBody.innerHTML = '';
 
-  // Show spinner while refreshing
+  // Show spinner while fetching usage via PTY
   const spinner = document.createElement('div');
   spinner.className = 'stats-spinner';
   spinner.innerHTML = `<div class="stats-spinner-icon"></div><span>Updating stats\u2026</span>`;
   statsViewerBody.appendChild(spinner);
 
-  // Refresh stats cache via PTY (/stats + /usage)
+  // Fetch stats from DB (instant) and usage from API (PTY) in parallel via
+  // refresh-stats, which now skips the slow /stats PTY call entirely.
   let stats, usage;
   try {
     const result = await window.api.refreshStats();
@@ -20,8 +21,8 @@ async function loadStats() {
     usage = result?.usage || {};
     cachedUsage = usage;
   } catch {
-    // Fallback to cached stats
-    stats = await window.api.getStats();
+    // Fallback: read DB directly for heatmap, use last cached usage
+    stats = await window.api.getStatsFromDb();
     usage = cachedUsage || {};
   }
 
@@ -33,9 +34,9 @@ async function loadStats() {
   }
 
   if (stats) {
-    // dailyActivity may be an array of {date, messageCount, ...} or an object
-    const rawDaily = stats.dailyActivity || {};
-    let dailyMap = {};
+    // dailyActivity is an array of {date, messageCount, sessionCount}
+    const rawDaily = stats.dailyActivity || [];
+    const dailyMap = {};
     if (Array.isArray(rawDaily)) {
       for (const entry of rawDaily) {
         dailyMap[entry.date] = entry.messageCount || 0;
@@ -59,7 +60,7 @@ async function loadStats() {
     const notice = document.createElement('div');
     notice.className = 'stats-notice';
     const lastDate = stats.lastComputedDate || 'unknown';
-    notice.innerHTML = `<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" style="vertical-align:-2px;margin-right:6px;flex-shrink:0"><circle cx="8" cy="8" r="7"/><line x1="8" y1="5" x2="8" y2="9"/><circle cx="8" cy="11.5" r="0.5" fill="currentColor" stroke="none"/></svg>Data sourced from Claude\u2019s stats cache (last updated ${escapeHtml(lastDate)}).`;
+    notice.innerHTML = `<svg width="14" height="14" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" style="vertical-align:-2px;margin-right:6px;flex-shrink:0"><circle cx="8" cy="8" r="7"/><line x1="8" y1="5" x2="8" y2="9"/><circle cx="8" cy="11.5" r="0.5" fill="currentColor" stroke="none"/></svg>Data sourced from Switchboard session cache (last updated ${escapeHtml(lastDate)}).`;
     statsViewerBody.appendChild(notice);
   }
 }
diff --git a/public/style.css b/public/style.css
index f6070c0..31c85da 100644
--- a/public/style.css
+++ b/public/style.css
@@ -341,6 +341,23 @@ body { display: flex; flex-direction: column; }
   color: #ffffff;
 }
 
+#search-refresh-btn {
+  position: absolute;
+  right: 60px;
+  top: 0;
+  height: calc(100% - 14px);
+  display: flex;
+  align-items: center;
+  background: none;
+  border: none;
+  color: #5a5a70;
+  cursor: pointer;
+  padding: 0 4px;
+  transition: color 0.15s;
+}
+#search-refresh-btn:hover { color: #b0b0c4; }
+#search-refresh-btn.spinning svg { animation: spin-dot 0.8s linear infinite; }
+
 
 /* ---- Scrollable content ---- */
 #sidebar-content {
@@ -1480,6 +1497,155 @@ body { display: flex; flex-direction: column; }
 }
 
 
+/* ========== SUBAGENT SIDEBAR ========== */
+
+/* Caret toggle row that appears below a parent session item */
+.sidebar-children-caret {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  margin: 0 12px 0 28px;
+  padding: 2px 6px;
+  font-size: 10px;
+  color: #7a7a96;
+  cursor: pointer;
+  user-select: none;
+  border-radius: 4px;
+  transition: color 0.12s, background 0.12s;
+}
+
+.sidebar-children-caret:hover {
+  color: #b0b0c8;
+  background: rgba(255,255,255,0.05);
+}
+
+.sidebar-children-caret .caret-arrow {
+  display: inline-block;
+  font-size: 8px;
+  transition: transform 0.15s;
+}
+
+.sidebar-children-caret.expanded .caret-arrow {
+  transform: rotate(90deg);
+}
+
+/* Container for the child subagent items */
+.sidebar-subagents-container {
+  /* display toggled via JS */
+}
+
+/* Nested subagent row */
+.sidebar-subagent {
+  padding-left: 28px !important;
+  border-left: 2px solid transparent;
+  margin-left: 12px;
+  font-size: 11.5px;
+}
+
+.sidebar-subagent .session-row {
+  padding: 6px 8px !important;
+  gap: 6px !important;
+}
+
+.sidebar-subagent .session-summary {
+  font-size: 11.5px;
+  color: #c0c0d4;
+}
+
+.sidebar-subagent .session-meta {
+  font-size: 10px;
+  color: #6a6a80;
+}
+
+/* Subagent type pill */
+.sidebar-subagent-type {
+  flex-shrink: 0;
+  font-size: 9px;
+  font-weight: 600;
+  letter-spacing: 0.3px;
+  text-transform: uppercase;
+  padding: 1px 5px;
+  border-radius: 3px;
+  border: 1px solid transparent;
+  color: #e0e0f0;
+  white-space: nowrap;
+  line-height: 1.6;
+}
+
+/* Orphan subagent group label */
+.sidebar-orphan-subagents {
+  margin-top: 4px;
+  border-top: 1px solid rgba(255,255,255,0.05);
+}
+
+.sidebar-orphan-label {
+  padding: 4px 12px;
+  font-size: 9.5px;
+  color: #6a6a80;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  cursor: pointer;
+  user-select: none;
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+.sidebar-orphan-label:hover { color: #b0b0c4; }
+.sidebar-orphan-label .orphan-caret {
+  display: inline-block;
+  transition: transform 0.12s;
+  font-size: 10px;
+}
+.sidebar-orphan-subagents:not(.collapsed) .orphan-caret {
+  transform: rotate(90deg);
+}
+.sidebar-orphan-label .orphan-count {
+  margin-left: 4px;
+  opacity: 0.6;
+}
+.sidebar-orphan-subagents.collapsed > :not(.sidebar-orphan-label) {
+  display: none;
+}
+
+/* ========== SUBAGENT GRID PILLS ========== */
+
+/* Horizontal pill strip shown in grid card above the footer */
+.grid-subagent-pills {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 10px;
+  background: rgba(255,255,255,0.02);
+  border-top: 1px solid rgba(255,255,255,0.04);
+  flex-shrink: 0;
+  flex-wrap: nowrap;
+  overflow: hidden;
+}
+
+/* Single colored dot pill — tooltip shows type */
+.grid-subagent-pill {
+  width: 10px;
+  height: 6px;
+  border-radius: 3px;
+  flex-shrink: 0;
+  opacity: 0.85;
+  transition: opacity 0.12s, transform 0.12s;
+  cursor: default;
+}
+
+.grid-subagent-pill:hover {
+  opacity: 1;
+  transform: scaleY(1.3);
+}
+
+/* "+N more" overflow label */
+.grid-subagent-pill-overflow {
+  font-size: 9px;
+  color: #7a7a90;
+  white-space: nowrap;
+  margin-left: 2px;
+}
+
 /* ========== SCROLLBAR ========== */
 #sidebar-content::-webkit-scrollbar, #plans-content::-webkit-scrollbar { width: 5px; }
 #sidebar-content::-webkit-scrollbar-track, #plans-content::-webkit-scrollbar-track { background: transparent; }
@@ -2338,6 +2504,29 @@ body { display: flex; flex-direction: column; }
 .jsonl-tool-diff::-webkit-scrollbar-thumb,
 .jsonl-tool-content::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.06); border-radius: 2px; }
 
+.jsonl-agent-expandable {
+  cursor: pointer;
+  transition: background 0.1s;
+}
+.jsonl-agent-expandable:hover {
+  background: rgba(240, 160, 80, 0.07);
+  border-radius: 4px;
+}
+.jsonl-agent-caret {
+  display: inline-block;
+  font-family: monospace;
+  font-size: 0.8em;
+  margin-right: 3px;
+  user-select: none;
+}
+.jsonl-subagent-nested {
+  margin-left: 1.5em;
+  padding-left: 0.8em;
+  border-left: 2px solid rgba(240, 160, 80, 0.4);
+  margin-top: 2px;
+  margin-bottom: 2px;
+}
+
 .jsonl-toggle {
   font-size: 11px;
   font-weight: 500;
diff --git a/read-session-file.js b/read-session-file.js
index bb42318..e8cc41d 100644
--- a/read-session-file.js
+++ b/read-session-file.js
@@ -1,9 +1,41 @@
 const path = require('path');
 const fs = require('fs');
 
-/** Parse a single .jsonl file into a session object (or null if invalid) */
-function readSessionFile(filePath, folder, projectPath) {
-  const sessionId = path.basename(filePath, '.jsonl');
+/** Subagent transcripts land under <folder>/<parentSessionId>/subagents/agent-<agentId>.jsonl.
+ *  We surface them as first-class rows with a synthetic sessionId so they're addressable
+ *  exactly like top-level sessions (search, archive, rename, etc).
+ */
+function subagentSessionId(parentSessionId, agentId) {
+  return `sub:${parentSessionId}:${agentId}`;
+}
+
+/** Resolve the absolute jsonl path for a row from session_cache.
+ *  Works for both top-level sessions and subagents. */
+function resolveJsonlPath(projectsDir, row) {
+  if (!row || !row.folder) return null;
+  if (row.parentSessionId && row.agentId) {
+    return path.join(projectsDir, row.folder, row.parentSessionId, 'subagents', `agent-${row.agentId}.jsonl`);
+  }
+  return path.join(projectsDir, row.folder, row.sessionId + '.jsonl');
+}
+
+/** Read sidecar { agentType, description } if present. */
+function readSubagentMeta(jsonlPath) {
+  const metaPath = jsonlPath.replace(/\.jsonl$/, '.meta.json');
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Parse a single .jsonl file into a session object (or null if invalid).
+ *  opts.parentSessionId — if set, treat as a subagent transcript and stamp the
+ *  parent reference into the returned row.
+ */
+function readSessionFile(filePath, folder, projectPath, opts = {}) {
+  const fileBase = path.basename(filePath, '.jsonl');
+  const isSubagent = Boolean(opts.parentSessionId);
   try {
     const stat = fs.statSync(filePath);
     const content = fs.readFileSync(filePath, 'utf8');
@@ -14,9 +46,18 @@ function readSessionFile(filePath, folder, projectPath) {
     let slug = null;
     let customTitle = null;
     let aiTitle = null;
+    let agentId = null;
+    let sidechainSeen = false;
     for (const line of lines) {
-      const entry = JSON.parse(line);
+      // Per-line try/catch: a JSONL file being written concurrently by a live
+      // Claude CLI session can have its tail captured mid-write — one truncated
+      // line should not invalidate the whole file. Skip the malformed line and
+      // keep parsing.
+      let entry;
+      try { entry = JSON.parse(line); } catch { continue; }
       if (entry.slug && !slug) slug = entry.slug;
+      if (entry.agentId && !agentId) agentId = entry.agentId;
+      if (entry.isSidechain) sidechainSeen = true;
       if (entry.type === 'custom-title' && entry.customTitle) {
         customTitle = entry.customTitle;
       }
@@ -44,8 +85,37 @@ function readSessionFile(filePath, folder, projectPath) {
       }
     }
     if (!summary || messageCount < 1) return null;
+
+    if (isSubagent) {
+      // Sidechain marker must be present — otherwise the file lives under a
+      // subagents/ directory but isn't actually a subagent transcript. Bail.
+      if (!sidechainSeen) return null;
+      if (!agentId) {
+        // Fall back to filename: agent-<id>.jsonl
+        const m = fileBase.match(/^agent-(.+)$/);
+        if (m) agentId = m[1];
+      }
+      if (!agentId) return null;
+      const meta = readSubagentMeta(filePath) || {};
+      const subagentType = meta.agentType || null;
+      const description = meta.description || null;
+      return {
+        sessionId: subagentSessionId(opts.parentSessionId, agentId),
+        folder, projectPath,
+        summary: description || summary,
+        firstPrompt: summary,
+        created: stat.birthtime.toISOString(),
+        modified: stat.mtime.toISOString(),
+        messageCount, textContent, slug, customTitle, aiTitle,
+        parentSessionId: opts.parentSessionId,
+        agentId,
+        subagentType,
+        description,
+      };
+    }
+
     return {
-      sessionId, folder, projectPath,
+      sessionId: fileBase, folder, projectPath,
       summary, firstPrompt: summary,
       created: stat.birthtime.toISOString(),
       modified: stat.mtime.toISOString(),
@@ -56,4 +126,150 @@ function readSessionFile(filePath, folder, projectPath) {
   }
 }
 
-module.exports = { readSessionFile };
+/** Enumerate every jsonl in a project folder: top-level sessions plus any
+ *  subagent transcripts under <folder>/<parentSessionId>/subagents/*.jsonl
+ *  (or directly under <folder>/<parentSessionId>/*.jsonl for legacy layouts).
+ *  Returns [{ filePath, sessionId, parentSessionId|null }]. */
+function enumerateSessionFiles(folderPath) {
+  const out = [];
+  let topEntries;
+  try {
+    topEntries = fs.readdirSync(folderPath, { withFileTypes: true });
+  } catch { return out; }
+
+  // Top-level .jsonl files = ordinary sessions
+  for (const e of topEntries) {
+    if (e.isFile() && e.name.endsWith('.jsonl')) {
+      out.push({
+        filePath: path.join(folderPath, e.name),
+        sessionId: path.basename(e.name, '.jsonl'),
+        parentSessionId: null,
+      });
+    }
+  }
+
+  // UUID subdirs may hold subagent transcripts
+  for (const e of topEntries) {
+    if (!e.isDirectory()) continue;
+    const parentSessionId = e.name;
+    const subDir = path.join(folderPath, parentSessionId);
+    // Preferred layout: subagents/ subfolder
+    const subagentsDir = path.join(subDir, 'subagents');
+    try {
+      if (fs.statSync(subagentsDir).isDirectory()) {
+        for (const f of fs.readdirSync(subagentsDir)) {
+          if (!f.endsWith('.jsonl')) continue;
+          out.push({
+            filePath: path.join(subagentsDir, f),
+            sessionId: path.basename(f, '.jsonl'),
+            parentSessionId,
+          });
+        }
+        continue;
+      }
+    } catch {}
+    // Fallback: jsonl directly in the UUID dir (older CLI versions)
+    try {
+      for (const f of fs.readdirSync(subDir)) {
+        if (!f.endsWith('.jsonl')) continue;
+        out.push({
+          filePath: path.join(subDir, f),
+          sessionId: path.basename(f, '.jsonl'),
+          parentSessionId,
+        });
+      }
+    } catch {}
+  }
+
+  return out;
+}
+
+/** Lightweight refresh path. Reads only the first ~256 KB / 500 lines of a
+ *  jsonl file to extract display-level metadata (summary, slug, titles,
+ *  agentId). Does NOT compute textContent or messageCount — the caller is
+ *  expected to merge with the cached row for unchanged fields. Designed so
+ *  the fs.watch flush can update a live 200+ MB host-session JSONL in ~ms
+ *  instead of seconds.
+ *
+ *  Returns the same shape as the display subset of readSessionFile() so it
+ *  can be merged into a cached row before upsert. Returns null if the chunk
+ *  doesn't yet contain a usable first-user-message.
+ */
+function readSessionDisplayHeader(filePath, opts = {}) {
+  const fileBase = path.basename(filePath, '.jsonl');
+  const isSubagent = Boolean(opts.parentSessionId);
+  const MAX_BYTES = 256 * 1024;
+  const MAX_LINES = 500;
+  try {
+    const stat = fs.statSync(filePath);
+    const readLen = Math.min(MAX_BYTES, stat.size);
+    const fd = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(readLen);
+    const n = fs.readSync(fd, buf, 0, readLen, 0);
+    fs.closeSync(fd);
+    const text = buf.toString('utf8', 0, n);
+    const lines = text.split('\n');
+    // Drop the potentially-partial last line unless we read the whole file
+    if (n < stat.size) lines.pop();
+
+    let summary = '';
+    let slug = null, customTitle = null, aiTitle = null, agentId = null;
+    let sidechainSeen = false;
+    let lineCount = 0;
+    for (const line of lines) {
+      if (!line) continue;
+      if (++lineCount > MAX_LINES) break;
+      let entry;
+      try { entry = JSON.parse(line); } catch { continue; }
+      if (entry.slug && !slug) slug = entry.slug;
+      if (entry.agentId && !agentId) agentId = entry.agentId;
+      if (entry.isSidechain) sidechainSeen = true;
+      if (entry.type === 'custom-title' && entry.customTitle && !customTitle) customTitle = entry.customTitle;
+      if (entry.type === 'ai-title' && entry.aiTitle && !aiTitle) aiTitle = entry.aiTitle;
+      const msg = entry.message;
+      const txt = typeof msg === 'string' ? msg :
+        (typeof msg?.content === 'string' ? msg.content :
+        (msg?.content?.[0]?.text || ''));
+      if (!summary && (entry.type === 'user' || (entry.type === 'message' && entry.role === 'user'))) {
+        if (txt && !/<bash-input>|<bash-stdout>|<local-command-caveat>/.test(txt)) {
+          const taskMatch = txt.match(/<scheduled-task\s+name="([^"]+)"/);
+          summary = taskMatch ? 'Scheduled: ' + taskMatch[1] : txt.slice(0, 120);
+        }
+      }
+    }
+
+    if (!summary) return null;
+
+    if (isSubagent) {
+      if (!sidechainSeen) return null;
+      if (!agentId) {
+        const m = fileBase.match(/^agent-(.+)$/);
+        if (m) agentId = m[1];
+      }
+      if (!agentId) return null;
+      const meta = readSubagentMeta(filePath) || {};
+      return {
+        sessionId: subagentSessionId(opts.parentSessionId, agentId),
+        summary: meta.description || summary,
+        firstPrompt: summary,
+        modified: stat.mtime.toISOString(),
+        slug, customTitle, aiTitle,
+        parentSessionId: opts.parentSessionId,
+        agentId,
+        subagentType: meta.agentType || null,
+        description: meta.description || null,
+      };
+    }
+
+    return {
+      sessionId: fileBase,
+      summary, firstPrompt: summary,
+      modified: stat.mtime.toISOString(),
+      slug, customTitle, aiTitle,
+    };
+  } catch {
+    return null;
+  }
+}
+
+module.exports = { readSessionFile, readSessionDisplayHeader, subagentSessionId, resolveJsonlPath, readSubagentMeta, enumerateSessionFiles };
diff --git a/session-cache.js b/session-cache.js
index f066004..fb606d9 100644
--- a/session-cache.js
+++ b/session-cache.js
@@ -3,7 +3,7 @@ const fs = require('fs');
 const { Worker } = require('worker_threads');
 const { getFolderIndexMtimeMs } = require('./folder-index-state');
 const { deriveProjectPath } = require('./derive-project-path');
-const { readSessionFile } = require('./read-session-file');
+const { readSessionFile, readSessionDisplayHeader, enumerateSessionFiles, resolveJsonlPath } = require('./read-session-file');
 const { encodeProjectPath } = require('./encode-project-path');
 
 /**
@@ -11,7 +11,7 @@ const { encodeProjectPath } = require('./encode-project-path');
  * Call init(ctx) once with the shared context object.
  */
 let PROJECTS_DIR, activeSessions, getMainWindow, log;
-let deleteCachedFolder, getCachedByFolder, upsertCachedSessions, deleteCachedSession;
+let deleteCachedFolder, getCachedByFolder, upsertCachedSessions, deleteCachedSession, touchCachedModified;
 let deleteSearchFolder, deleteSearchSession, upsertSearchEntries;
 let setFolderMeta, getAllFolderMeta, getAllMeta, getAllCached, getSetting, getMeta, setName;
 
@@ -24,6 +24,7 @@ function init(ctx) {
   deleteCachedFolder = ctx.db.deleteCachedFolder;
   getCachedByFolder = ctx.db.getCachedByFolder;
   upsertCachedSessions = ctx.db.upsertCachedSessions;
+  touchCachedModified = ctx.db.touchCachedModified;
   deleteCachedSession = ctx.db.deleteCachedSession;
   deleteSearchFolder = ctx.db.deleteSearchFolder;
   deleteSearchSession = ctx.db.deleteSearchSession;
@@ -46,19 +47,25 @@ function readFolderFromFilesystem(folder) {
   if (!projectPath) return { projectPath: null, sessions: [] };
   const sessions = [];
 
-  try {
-    const jsonlFiles = fs.readdirSync(folderPath).filter(f => f.endsWith('.jsonl'));
-    for (const file of jsonlFiles) {
-      const s = readSessionFile(path.join(folderPath, file), folder, projectPath);
-      if (s) sessions.push(s);
-    }
-  } catch {}
+  for (const { filePath, parentSessionId } of enumerateSessionFiles(folderPath)) {
+    const s = readSessionFile(filePath, folder, projectPath, { parentSessionId });
+    if (s) sessions.push(s);
+  }
 
   return { projectPath, sessions };
 }
 
-/** Refresh a single folder incrementally: only re-read changed/new .jsonl files */
-function refreshFolder(folder) {
+/** Refresh a single folder incrementally: only re-read changed/new .jsonl files.
+ *
+ * @param {string} folder    folder name relative to PROJECTS_DIR
+ * @param {object} [opts]
+ * @param {Set<string>|null} [opts.files]  if provided, ONLY scan these on-disk
+ *   relative paths within the folder instead of walking everything. Used by the
+ *   fs.watch flush to avoid statSync'ing thousands of files when only a handful
+ *   of subagent transcripts were appended. When null/undefined, walk the whole
+ *   folder (used for bootstrap and folder-level events).
+ */
+function refreshFolder(folder, opts = {}) {
   const folderPath = path.join(PROJECTS_DIR, folder);
   if (!fs.existsSync(folderPath)) {
     deleteCachedFolder(folder);
@@ -71,18 +78,50 @@ function refreshFolder(folder) {
     return;
   }
 
-  // Get what's currently cached for this folder
+  // Get what's currently cached for this folder.
+  // cachedMap: DB sessionId → { modified, filePath } so we can do mtime comparison
+  // even for subagents whose DB sessionId differs from the on-disk filename.
+  // filePathToDbId: inverted index so the per-file lookup is O(1) — without it,
+  // refreshing a folder with N cached sessions costs O(N²) per flush (the watcher
+  // fires frequently while live Claude sessions append JSONL, freezing the main
+  // process for folders with thousands of subagents).
   const cachedSessions = getCachedByFolder(folder);
-  const cachedMap = new Map(); // sessionId → modified ISO string
+  const cachedMap = new Map();
+  const filePathToDbId = new Map();
   for (const row of cachedSessions) {
-    cachedMap.set(row.sessionId, row.modified);
+    const filePath = resolveJsonlPath(PROJECTS_DIR, row);
+    // Keep the full row so refresh can merge display-only header updates with
+    // unchanged fields (created, messageCount, textContent) without re-reading
+    // the file body.
+    cachedMap.set(row.sessionId, { ...row, filePath });
+    filePathToDbId.set(filePath, row.sessionId);
   }
 
-  // Scan current .jsonl files
-  let jsonlFiles;
-  try {
-    jsonlFiles = fs.readdirSync(folderPath).filter(f => f.endsWith('.jsonl'));
-  } catch { return; }
+  // Targeted refresh: walk only the files the watcher said changed, not the
+  // entire folder. Skips enumerateSessionFiles (which does many readdirSyncs on
+  // every subagent subdir) and only stats the dirty files. Falls back to full
+  // walk when opts.files is omitted (bootstrap / folder-level events / cold
+  // delete-detection).
+  const targeted = opts.files instanceof Set && opts.files.size > 0;
+  let filesToScan;
+  if (targeted) {
+    filesToScan = [];
+    for (const rel of opts.files) {
+      const filePath = path.join(folderPath, rel);
+      // Derive parentSessionId for subagent paths: <folder>/<parent>/subagents/agent-X.jsonl
+      const parts = rel.split(path.sep);
+      let parentSessionId = null;
+      if (parts.length === 3 && parts[1] === 'subagents') {
+        parentSessionId = parts[0];
+      } else if (parts.length === 2) {
+        // legacy <folder>/<parent>/agent-X.jsonl layout (no subagents/ subdir)
+        parentSessionId = parts[0];
+      }
+      filesToScan.push({ filePath, parentSessionId });
+    }
+  } else {
+    filesToScan = enumerateSessionFiles(folderPath);
+  }
 
   const currentIds = new Set();
   let changed = false;
@@ -93,22 +132,66 @@ function refreshFolder(folder) {
   const namesToSet = [];
   const sessionsToDelete = [];
 
-  for (const file of jsonlFiles) {
-    const filePath = path.join(folderPath, file);
-    const sessionId = path.basename(file, '.jsonl');
-    currentIds.add(sessionId);
+  // Refresh strategy:
+  //   - NEW file (no cache row): full readSessionFile — small at first turn,
+  //     seeds session_cache + FTS body in one shot.
+  //   - EXISTING file (already cached): header-only read (~256 KB / 500 lines).
+  //     Updates display fields (summary, slug, titles, mtime) without reading
+  //     the full body. Avoids re-reading 200+ MB live host-session JSONLs on
+  //     every watcher flush. Side-effect: FTS body for live sessions goes
+  //     stale until the next cold-start (acceptable trade-off).
+  //   - Header read failing (truncated chunk, partial JSON): fall back to a
+  //     mtime-only DB touch so the sidebar still reflects activity.
+
+  for (const { filePath, parentSessionId } of filesToScan) {
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { continue; }
+    const fileMtime = stat.mtime.toISOString();
 
-    // Check if file mtime changed
-    let fileMtime;
-    try { fileMtime = fs.statSync(filePath).mtime.toISOString(); } catch { continue; }
+    const cachedDbId = filePathToDbId.get(filePath) || null;
+    const cachedEntry = cachedDbId ? cachedMap.get(cachedDbId) : null;
 
-    if (cachedMap.has(sessionId) && cachedMap.get(sessionId) === fileMtime) {
+    if (cachedDbId !== null) currentIds.add(cachedDbId);
+
+    if (cachedEntry && cachedEntry.modified === fileMtime) {
       continue; // unchanged, skip
     }
 
-    // File is new or modified — re-read it
-    const s = readSessionFile(filePath, folder, projectPath);
+    if (cachedEntry) {
+      // EXISTING — header-only refresh.
+      const h = readSessionDisplayHeader(filePath, { parentSessionId });
+      if (h) {
+        // Merge: keep cached body/messageCount/created, overlay fresh display fields.
+        const merged = {
+          ...cachedEntry,
+          folder, projectPath,
+          summary: h.summary || cachedEntry.summary,
+          firstPrompt: h.firstPrompt || cachedEntry.firstPrompt,
+          modified: fileMtime,
+          slug: h.slug || cachedEntry.slug,
+          aiTitle: h.aiTitle || cachedEntry.aiTitle,
+          parentSessionId: h.parentSessionId || cachedEntry.parentSessionId,
+          agentId: h.agentId || cachedEntry.agentId,
+          subagentType: h.subagentType || cachedEntry.subagentType,
+          description: h.description || cachedEntry.description,
+        };
+        sessionsToUpsert.push(merged);
+        if (h.customTitle && h.customTitle !== cachedEntry.customTitle) {
+          namesToSet.push({ id: merged.sessionId, name: h.customTitle });
+        }
+      } else {
+        // Header read couldn't extract signal — just bump mtime so sort order stays current.
+        touchCachedModified(cachedDbId, fileMtime);
+        cachedEntry.modified = fileMtime;
+      }
+      changed = true;
+      continue;
+    }
+
+    // NEW file — full readSessionFile so the FTS index gets seeded.
+    const s = readSessionFile(filePath, folder, projectPath, { parentSessionId });
     if (s) {
+      currentIds.add(s.sessionId);
       sessionsToUpsert.push(s);
       // Title precedence: user rename (session_meta.name) > JSONL custom-title > JSONL ai-title.
       // Only customTitle (Claude /title) promotes to session_meta.name — AI titles must NEVER
@@ -123,11 +206,29 @@ function refreshFolder(folder) {
     changed = true;
   }
 
-  // Remove sessions whose .jsonl files were deleted
-  for (const sessionId of cachedMap.keys()) {
-    if (!currentIds.has(sessionId)) {
-      sessionsToDelete.push(sessionId);
-      changed = true;
+  // Remove sessions whose .jsonl files were deleted. Skip in targeted mode —
+  // we only stat'd the dirty files, so cachedMap entries not in currentIds
+  // weren't checked and may still exist on disk. Targeted-mode deletions are
+  // handled by the watcher path-stat: missing files surface via statSync's
+  // ENOENT in the loop above and produce no upsert. A full walk picks up any
+  // drift on the next folder-level event.
+  if (!targeted) {
+    for (const sessionId of cachedMap.keys()) {
+      if (!currentIds.has(sessionId)) {
+        sessionsToDelete.push(sessionId);
+        changed = true;
+      }
+    }
+  } else {
+    // Targeted mode still needs to delete entries for files explicitly deleted
+    // in this flush — detected by statSync failing on a path we tried to scan.
+    for (const { filePath } of filesToScan) {
+      const dbId = filePathToDbId.get(filePath);
+      if (!dbId) continue;
+      try { fs.statSync(filePath); } catch {
+        sessionsToDelete.push(dbId);
+        changed = true;
+      }
     }
   }
 
@@ -197,6 +298,10 @@ function buildProjectsFromCache(showArchived) {
       projectPath: row.projectPath,
       slug: row.slug || null,
       aiTitle: row.aiTitle || null,
+      parentSessionId: row.parentSessionId || null,
+      agentId: row.agentId || null,
+      subagentType: row.subagentType || null,
+      description: row.description || null,
       name: meta?.name || null,
       starred: meta?.starred || 0,
       archived: meta?.archived || 0,
@@ -282,11 +387,27 @@ function buildProjectsFromCache(showArchived) {
 }
 
 
+// Throttle projects-changed IPC: live sessions appending JSONL trigger a flush
+// every ~500ms; without throttling the renderer re-runs getProjects + morphdom
+// over 100+ items at that cadence, producing visible flicker. Leading-edge fire
+// + trailing flush so the first change is instant but subsequent bursts coalesce.
+const NOTIFY_THROTTLE_MS = 1500;
+let _notifyCooldown = false;
+let _notifyPending = false;
 function notifyRendererProjectsChanged() {
+  if (_notifyCooldown) { _notifyPending = true; return; }
   const mainWindow = getMainWindow();
   if (mainWindow && !mainWindow.isDestroyed()) {
     mainWindow.webContents.send('projects-changed');
   }
+  _notifyCooldown = true;
+  setTimeout(() => {
+    _notifyCooldown = false;
+    if (_notifyPending) {
+      _notifyPending = false;
+      notifyRendererProjectsChanged();
+    }
+  }, NOTIFY_THROTTLE_MS);
 }
 
 function sendStatus(text, type) {
@@ -297,14 +418,25 @@ function sendStatus(text, type) {
   }
 }
 
-// --- Worker-based cache population (non-blocking) ---
-let populatingCache = false;
+// --- Worker-based cache population ---
+// Returns a Promise that resolves when the in-flight scan finishes. Concurrent
+// callers share the same Promise so the first get-projects after a migration
+// can await it instead of seeing an empty list.
+let populatePromise = null;
 
 function populateCacheViaWorker() {
-  if (populatingCache) return;
-  populatingCache = true;
+  if (populatePromise) return populatePromise;
   sendStatus('Scanning projects\u2026', 'active');
 
+  populatePromise = new Promise((resolve) => {
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      populatePromise = null;
+      resolve();
+    };
+
   const worker = new Worker(path.join(__dirname, 'workers', 'scan-projects.js'), {
     workerData: { projectsDir: PROJECTS_DIR },
   });
@@ -319,7 +451,7 @@ function populateCacheViaWorker() {
     if (!msg.ok) {
       console.error('Worker scan error:', msg.error);
       sendStatus('Scan failed: ' + msg.error, 'error');
-      populatingCache = false;
+      settle();
       return;
     }
 
@@ -351,30 +483,28 @@ function populateCacheViaWorker() {
       setFolderMeta(folder, projectPath, indexMtimeMs);
     }
 
-    populatingCache = false;
     sendStatus(`Indexed ${sessionCount} sessions across ${msg.results.length} projects`, 'done');
     // Clear status after a few seconds
     setTimeout(() => sendStatus(''), 5000);
     notifyRendererProjectsChanged();
+    settle();
   });
 
   worker.on('error', (err) => {
     console.error('Worker error:', err);
     sendStatus('Worker error: ' + err.message, 'error');
-    populatingCache = false;
+    settle();
   });
 
   // If the worker exits abnormally (SIGSEGV, OOM, uncaught exception) without
   // sending a message, neither the 'message' nor 'error' handler will fire.
-  // Reset the flag here to prevent a permanent lockout where the session list
-  // stays empty because populateCacheViaWorker() returns immediately.
+  // Resolve here so awaiters aren't stuck forever and the next call can retry.
   worker.on('exit', (code) => {
-    if (populatingCache) {
-      populatingCache = false;
-      if (code !== 0) {
-        sendStatus('Scan worker exited unexpectedly', 'error');
-      }
+    if (!settled && code !== 0) {
+      sendStatus('Scan worker exited unexpectedly', 'error');
     }
+    settle();
+  });
   });
 }
 
diff --git a/session-transitions.js b/session-transitions.js
index ef9f25a..784f982 100644
--- a/session-transitions.js
+++ b/session-transitions.js
@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs');
+const { readSubagentMeta } = require('./read-session-file');
 
 /**
  * Fork / plan-accept detection for active PTY sessions.
@@ -15,6 +16,108 @@ function init(ctx) {
   rekeyMcpServer = ctx.rekeyMcpServer;
 }
 
+// --- Subagent spawn / completion detection ---
+
+/** Walk <folder>/<sessionId>/subagents/ and detect new or completed subagent files.
+ *  Mutates session.knownSubagents (Map<agentId, { mtimeMs, completed }>).
+ *  Emits IPC 'subagent-spawned' and 'subagent-completed' via mainWindow.
+ *  `now` is injectable so callers (tests) can freeze the clock for determinism. */
+function detectSubagentTransitions(sessionId, session, folderPath, now = Date.now()) {
+  const subagentsDir = path.join(folderPath, sessionId, 'subagents');
+  let files;
+  try {
+    files = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
+  } catch {
+    return; // directory doesn't exist yet — normal
+  }
+
+  // First walk for this session: pre-populate knownSubagents with every
+  // existing file silently so we don't flood the renderer with spawn/complete
+  // events for agents that already finished before Switchboard started watching.
+  // Files modified in the last 60s get a normal lifecycle; older ones are
+  // recorded as already-completed without IPC.
+  const isBootstrap = !session.knownSubagents;
+  if (isBootstrap) {
+    session.knownSubagents = new Map();
+  }
+
+  const mainWindow = getMainWindow();
+  const STABLE_MS = 30000; // 30 seconds of no mtime advance → completed
+  const BOOTSTRAP_LIVE_MS = 60000; // file modified in last 60s = still alive at boot
+
+  for (const file of files) {
+    // agent-<agentId>.jsonl
+    const m = file.match(/^agent-(.+)\.jsonl$/);
+    if (!m) continue;
+    const agentId = m[1];
+    const filePath = path.join(subagentsDir, file);
+
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { continue; }
+    const mtimeMs = stat.mtimeMs;
+
+    const known = session.knownSubagents.get(agentId);
+
+    if (!known) {
+      if (isBootstrap) {
+        // Cold-start initialization — record silently without firing IPC.
+        // Treat recently-modified files as still-active so they can complete
+        // through the normal lifecycle; treat older ones as already done.
+        const looksAlive = (now - mtimeMs) < BOOTSTRAP_LIVE_MS;
+        session.knownSubagents.set(agentId, {
+          mtimeMs,
+          completed: !looksAlive,
+          _completedAt: looksAlive ? null : now,
+        });
+        continue;
+      }
+      // First sighting post-bootstrap — real spawn event
+      const meta = readSubagentMeta(filePath) || {};
+      session.knownSubagents.set(agentId, { mtimeMs, completed: false });
+      log.info(`[subagent-spawn] parent=${sessionId} agentId=${agentId} type=${meta.agentType || 'unknown'}`);
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send('subagent-spawned', {
+          parentSessionId: sessionId,
+          agentId,
+          subagentType: meta.agentType || null,
+          description: meta.description || null,
+        });
+      }
+    } else if (!known.completed) {
+      if (mtimeMs !== known.mtimeMs) {
+        // File is still being written — update mtime, reset stability clock
+        known.mtimeMs = mtimeMs;
+        known._stableStart = null;
+      } else {
+        // mtime stable — start or continue stability timer
+        if (!known._stableStart) {
+          known._stableStart = now;
+        } else if (now - known._stableStart >= STABLE_MS) {
+          known.completed = true;
+          log.info(`[subagent-complete] parent=${sessionId} agentId=${agentId}`);
+          if (mainWindow && !mainWindow.isDestroyed()) {
+            mainWindow.webContents.send('subagent-completed', {
+              parentSessionId: sessionId,
+              agentId,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // GC: remove completed entries after 5 minutes to avoid unbounded growth
+  const GC_TTL = 5 * 60 * 1000;
+  for (const [agentId, state] of session.knownSubagents) {
+    if (state.completed && state._completedAt && now - state._completedAt > GC_TTL) {
+      session.knownSubagents.delete(agentId);
+    }
+    if (state.completed && !state._completedAt) {
+      state._completedAt = now;
+    }
+  }
+}
+
 // --- Fork / plan-accept detection ---
 
 /** Read first few lines of a new .jsonl to extract signals.
@@ -85,6 +188,12 @@ function detectSessionTransitions(folder) {
   } catch { return; }
 
   for (const [sessionId, session] of [...activeSessions]) {
+    // Run subagent detection for all non-exited, non-terminal sessions in this folder
+    if (!session.exited && !session.isPlainTerminal && session.projectFolder === folder) {
+      const effectiveSessionId = session.realSessionId || sessionId;
+      detectSubagentTransitions(effectiveSessionId, session, folderPath);
+    }
+
     if (session.exited || session.isPlainTerminal || !session.knownJsonlFiles || session.projectFolder !== folder) {
       if (!session.exited && !session.isPlainTerminal && session.forkFrom) {
         log.info(`[fork-detect] skipped session=${sessionId} forkFrom=${session.forkFrom||'none'} reason=${session.exited ? 'exited' : session.isPlainTerminal ? 'terminal' : !session.knownJsonlFiles ? 'noKnown' : 'folderMismatch('+session.projectFolder+' vs '+folder+')'}`);
@@ -195,4 +304,4 @@ function detectSessionTransitions(folder) {
 }
 
 
-module.exports = { init, detectSessionTransitions };
+module.exports = { init, detectSessionTransitions, detectSubagentTransitions };
diff --git a/test/db-daily-activity.test.js b/test/db-daily-activity.test.js
new file mode 100644
index 0000000..1c8e79e
--- /dev/null
+++ b/test/db-daily-activity.test.js
@@ -0,0 +1,122 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+// getDailyActivity is powered by better-sqlite3, which is compiled against
+// Electron's Node ABI and cannot be required from plain node:test. These tests
+// therefore validate the aggregation LOGIC by running the same computation on
+// plain JS arrays — the SQL query is a straightforward GROUP BY that we mirror
+// here so regressions in the computation surface in CI.
+
+/**
+ * Pure-JS mirror of the getDailyActivity SQL:
+ *   SELECT substr(modified,1,10) AS date, SUM(messageCount), COUNT(*) AS sessionCount
+ *   FROM session_cache WHERE modified IS NOT NULL AND length(modified) >= 10
+ *   GROUP BY date ORDER BY date ASC
+ */
+function aggregateDailyActivity(rows) {
+  const map = new Map();
+  for (const row of rows) {
+    if (!row.modified || row.modified.length < 10) continue;
+    const date = row.modified.slice(0, 10);
+    const existing = map.get(date);
+    if (existing) {
+      existing.messageCount += row.messageCount || 0;
+      existing.sessionCount += 1;
+    } else {
+      map.set(date, { date, messageCount: row.messageCount || 0, sessionCount: 1 });
+    }
+  }
+  return Array.from(map.values()).sort((a, b) => a.date.localeCompare(b.date));
+}
+
+test('aggregateDailyActivity returns [] when input is empty', () => {
+  assert.deepEqual(aggregateDailyActivity([]), []);
+});
+
+test('aggregateDailyActivity sums messageCount and counts sessions per day', () => {
+  const rows = [
+    { sessionId: 's1', modified: '2026-03-15T10:05:00.000Z', messageCount: 10 },
+    { sessionId: 's2', modified: '2026-03-15T11:30:00.000Z', messageCount: 5 },
+    { sessionId: 's3', modified: '2026-03-16T09:45:00.000Z', messageCount: 20 },
+  ];
+  const result = aggregateDailyActivity(rows);
+  assert.equal(result.length, 2);
+  const mar15 = result.find(r => r.date === '2026-03-15');
+  const mar16 = result.find(r => r.date === '2026-03-16');
+  assert.ok(mar15);
+  assert.ok(mar16);
+  assert.equal(mar15.messageCount, 15);
+  assert.equal(mar15.sessionCount, 2);
+  assert.equal(mar16.messageCount, 20);
+  assert.equal(mar16.sessionCount, 1);
+});
+
+test('aggregateDailyActivity includes subagent rows (parentSessionId present)', () => {
+  const rows = [
+    { sessionId: 'parent-1', modified: '2026-04-01T08:10:00.000Z', messageCount: 3, parentSessionId: null },
+    { sessionId: 'sub:parent-1:agent-1', modified: '2026-04-01T08:20:00.000Z', messageCount: 8, parentSessionId: 'parent-1' },
+  ];
+  const result = aggregateDailyActivity(rows);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].date, '2026-04-01');
+  assert.equal(result[0].messageCount, 11, 'parent + subagent messages should both count');
+  assert.equal(result[0].sessionCount, 2, 'parent + subagent sessions should both count');
+});
+
+test('aggregateDailyActivity sorts results chronologically', () => {
+  const rows = [
+    { sessionId: 'x1', modified: '2026-02-10T01:00:00.000Z', messageCount: 1 },
+    { sessionId: 'x2', modified: '2026-05-01T01:00:00.000Z', messageCount: 1 },
+    { sessionId: 'x3', modified: '2026-03-20T01:00:00.000Z', messageCount: 1 },
+  ];
+  const result = aggregateDailyActivity(rows);
+  assert.deepEqual(result.map(r => r.date), ['2026-02-10', '2026-03-20', '2026-05-01']);
+});
+
+test('aggregateDailyActivity skips rows with null or short modified', () => {
+  const rows = [
+    { sessionId: 'a', modified: null, messageCount: 99 },
+    { sessionId: 'b', modified: '2026', messageCount: 99 },
+    { sessionId: 'c', modified: '2026-05-22T00:00:00.000Z', messageCount: 5 },
+  ];
+  const result = aggregateDailyActivity(rows);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].date, '2026-05-22');
+  assert.equal(result[0].messageCount, 5);
+});
+
+// Verify the stats-object shape built from getDailyActivity results (mirrors
+// the get-stats-from-db / refresh-stats IPC handler logic).
+test('stats object built from daily rows has correct totals and shape', () => {
+  const rows = [
+    { date: '2026-03-15', messageCount: 15, sessionCount: 2 },
+    { date: '2026-03-16', messageCount: 20, sessionCount: 1 },
+    { date: '2026-04-01', messageCount: 11, sessionCount: 2 },
+  ];
+
+  let totalMessages = 0;
+  let totalSessions = 0;
+  let firstSessionDate = null;
+  for (const row of rows) {
+    totalMessages += row.messageCount || 0;
+    totalSessions += row.sessionCount || 0;
+    if (!firstSessionDate) firstSessionDate = row.date;
+  }
+  const lastComputedDate = '2026-05-22';
+  const stats = {
+    dailyActivity: rows,
+    totalMessages,
+    totalSessions,
+    firstSessionDate: firstSessionDate || lastComputedDate,
+    lastComputedDate,
+    modelUsage: {},
+  };
+
+  assert.equal(stats.totalMessages, 46);
+  assert.equal(stats.totalSessions, 5);
+  assert.equal(stats.firstSessionDate, '2026-03-15');
+  assert.equal(stats.lastComputedDate, '2026-05-22');
+  assert.deepEqual(stats.modelUsage, {});
+  assert.equal(stats.dailyActivity.length, 3);
+  assert.ok(Array.isArray(stats.dailyActivity));
+});
diff --git a/test/derive-project-path.test.js b/test/derive-project-path.test.js
new file mode 100644
index 0000000..1b84829
--- /dev/null
+++ b/test/derive-project-path.test.js
@@ -0,0 +1,107 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { deriveProjectPath, resolveWorktreePath } = require('../derive-project-path');
+
+function mkTmp() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'switchboard-dpp-'));
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+test('resolveWorktreePath collapses /<repo>/.claude/worktrees/<name> back to <repo> when parent exists', () => {
+  const tmp = mkTmp();
+  try {
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const worktree = path.join(repo, '.claude', 'worktrees', 'agent-abc');
+    assert.equal(resolveWorktreePath(worktree), repo);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('resolveWorktreePath collapses /<repo>/.claude-worktrees/<name> back to <repo>', () => {
+  const tmp = mkTmp();
+  try {
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const worktree = path.join(repo, '.claude-worktrees', 'foo');
+    assert.equal(resolveWorktreePath(worktree), repo);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('resolveWorktreePath collapses /<repo>/.worktrees/<name> back to <repo>', () => {
+  const tmp = mkTmp();
+  try {
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const worktree = path.join(repo, '.worktrees', 'bar');
+    assert.equal(resolveWorktreePath(worktree), repo);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('resolveWorktreePath handles trailing-slash variant', () => {
+  const tmp = mkTmp();
+  try {
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const worktreeWithSlash = path.join(repo, '.worktrees', 'bar') + '/';
+    assert.equal(resolveWorktreePath(worktreeWithSlash), repo);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('resolveWorktreePath returns input unchanged when the parent dir does not exist on disk', () => {
+  // /nonexistent-xyzzy-12345/.claude/worktrees/agent-foo — regex matches, but parent dir absent
+  const fake = '/nonexistent-xyzzy-12345/.claude/worktrees/agent-foo';
+  assert.equal(resolveWorktreePath(fake), fake);
+});
+
+test('resolveWorktreePath returns input unchanged when the path does not match the worktree pattern', () => {
+  assert.equal(resolveWorktreePath('/repo/src/foo'), '/repo/src/foo');
+  assert.equal(resolveWorktreePath('/repo/.claude/agents/foo'), '/repo/.claude/agents/foo');
+  // Worktrees segment but two extra components (nested under worktree) — must not match
+  assert.equal(resolveWorktreePath('/repo/.worktrees/foo/bar'), '/repo/.worktrees/foo/bar');
+});
+
+test('resolveWorktreePath passes falsy input through unchanged without throwing', () => {
+  assert.equal(resolveWorktreePath(null), null);
+  assert.equal(resolveWorktreePath(undefined), undefined);
+  assert.equal(resolveWorktreePath(''), '');
+});
+
+test('deriveProjectPath end-to-end: jsonl with worktree cwd resolves to parent repo', () => {
+  const tmp = mkTmp();
+  try {
+    // Real on-disk repo so existsSync returns true
+    const repo = path.join(tmp, 'repo');
+    fs.mkdirSync(repo);
+    const worktreeCwd = path.join(repo, '.claude', 'worktrees', 'agent-x');
+    // worktreeCwd itself doesn't need to exist; only its derived parent does
+
+    // The folder we feed deriveProjectPath is a "projects/foo" style dir
+    // containing a single jsonl whose first cwd line points at the worktree.
+    const folder = path.join(tmp, 'project-folder');
+    fs.mkdirSync(folder);
+    fs.writeFileSync(
+      path.join(folder, 'session-1.jsonl'),
+      JSON.stringify({ type: 'user', cwd: worktreeCwd }) + '\n',
+      'utf8'
+    );
+
+    assert.equal(deriveProjectPath(folder), repo);
+  } finally {
+    cleanup(tmp);
+  }
+});
diff --git a/test/dom-setup.js b/test/dom-setup.js
new file mode 100644
index 0000000..4043eb2
--- /dev/null
+++ b/test/dom-setup.js
@@ -0,0 +1,195 @@
+// Shared jsdom bootstrap for renderer tests.
+//
+// public/*.js loads as classic <script> tags in Electron. To exercise it
+// from node:test we set up a jsdom Window, then evaluate the renderer
+// source inside that window's VM context. This mirrors what the browser
+// does: every top-level `function`/`const`/`let` lands on the window.
+//
+// The helper hands back a `ctx` with:
+//   - window / document — the jsdom window
+//   - sidebar — the public/sidebar.js module evaluated in window's context
+//   - destroy() — tear down jsdom and prevent global leaks between tests
+//
+// Cross-test isolation: each call to setupSidebarDom() returns a fresh
+// window. Nothing is shared on the host's global object.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { JSDOM } = require('jsdom');
+
+const PUBLIC_DIR = path.join(__dirname, '..', 'public');
+const MORPHDOM_PATH = path.join(__dirname, '..', 'node_modules', 'morphdom', 'dist', 'morphdom-umd.js');
+
+// Minimal DOM stub that index.html sets up. sidebar.js looks up several
+// of these by id via document.getElementById — we just need them present.
+const INDEX_HTML = `<!DOCTYPE html>
+<html>
+  <body>
+    <div id="sidebar-content"></div>
+    <div id="plans-content"></div>
+    <div id="stats-content"></div>
+    <div id="memory-content"></div>
+    <div id="placeholder"></div>
+    <div id="terminals"></div>
+  </body>
+</html>`;
+
+function setupSidebarDom() {
+  const dom = new JSDOM(INDEX_HTML, {
+    url: 'http://localhost/',
+    runScripts: 'outside-only',
+    pretendToBeVisual: true,
+  });
+  const { window } = dom;
+
+  // Stub Electron preload bridge — every IPC call resolves to a sensible
+  // default so user-event handlers don't throw when invoked.
+  window.api = new Proxy({}, {
+    get(_t, _prop) {
+      return () => Promise.resolve({ ok: true });
+    },
+  });
+
+  // Stubs for cross-file renderer globals consumed by sidebar.js.
+  // We intentionally use writable globals where sidebar.js mutates them.
+  const stubGlobals = {
+    // DOM handles normally set up by app.js
+    sidebarContent: window.document.getElementById('sidebar-content'),
+    plansContent: window.document.getElementById('plans-content'),
+    statsContent: window.document.getElementById('stats-content'),
+    memoryContent: window.document.getElementById('memory-content'),
+
+    // State maps / sets used by sidebar.js — defaults are empty.
+    openSessions: new Map(),
+    activeSessionId: null,
+    activePtyIds: new Set(),
+    pendingSessions: new Map(),
+    sessionMap: new Map(),
+    lastActivityTime: new Map(),
+    sortedOrder: [],
+    searchMatchIds: null,
+    searchMatchProjectPaths: null,
+    showStarredOnly: false,
+    showRunningOnly: false,
+    showTodayOnly: false,
+    visibleSessionCount: 10,
+    sessionMaxAgeDays: 3650, // generous so fixtures aren't filtered out by age
+    attentionSessions: new Set(),
+    responseReadySessions: new Set(),
+    sessionBusyState: new Map(),
+    cachedProjects: [],
+    cachedAllProjects: [],
+
+    // Functions normally defined in other renderer files. Tests don't
+    // exercise these click paths but rebindSidebarEvents wires the
+    // handlers, so they must at least exist.
+    showSession: () => {},
+    confirmAndStopSession: () => {},
+    pollActiveSessions: () => {},
+    showNewSessionPopover: () => {},
+    openSettingsViewer: () => {},
+    showResumeSessionDialog: () => {},
+    showJsonlViewer: () => {},
+    forkSession: () => {},
+    openSession: () => {},
+    loadProjects: () => {},
+    launchScheduleCreator: () => {},
+  };
+
+  for (const [k, v] of Object.entries(stubGlobals)) {
+    Object.defineProperty(window, k, { value: v, writable: true, configurable: true });
+  }
+
+  // morphdom: load the UMD build into the window so sidebar.js sees `morphdom` global.
+  const morphdomSrc = fs.readFileSync(MORPHDOM_PATH, 'utf8');
+  vm.runInContext(morphdomSrc, dom.getInternalVMContext(), { filename: 'morphdom-umd.js' });
+
+  // Real utils.js and icons.js — small and dependency-free.
+  evalInWindow(dom, path.join(PUBLIC_DIR, 'utils.js'));
+  evalInWindow(dom, path.join(PUBLIC_DIR, 'icons.js'));
+
+  // Finally, sidebar.js.
+  evalInWindow(dom, path.join(PUBLIC_DIR, 'sidebar.js'));
+
+  return {
+    window,
+    document: window.document,
+    sidebar: {
+      renderProjects: window.renderProjects,
+      buildSessionItem: window.buildSessionItem,
+      buildSubagentItem: window.buildSubagentItem,
+      folderId: window.folderId,
+    },
+    destroy() {
+      window.close();
+    },
+  };
+}
+
+function evalInWindow(dom, file) {
+  const src = fs.readFileSync(file, 'utf8');
+  vm.runInContext(src, dom.getInternalVMContext(), { filename: file });
+}
+
+// Build a deterministic sample project fixture.
+function makeSampleProject(overrides = {}) {
+  const projectPath = overrides.projectPath || '/home/dev/myproj';
+  const baseTime = Date.parse('2026-05-22T10:00:00Z');
+  const t = (offset) => new Date(baseTime + offset).toISOString();
+
+  // 2 top-level sessions, 3 subagents (one orphan — parent missing),
+  // 1 starred, 1 archived.
+  const sessions = [
+    {
+      sessionId: 's-top-1',
+      name: 'main session',
+      summary: 'top level 1',
+      modified: t(0),
+      starred: true,
+      archived: 0,
+      messageCount: 12,
+    },
+    {
+      sessionId: 's-top-2',
+      name: 'second session',
+      summary: 'top level 2',
+      modified: t(-1000),
+      starred: false,
+      archived: 1, // archived
+      messageCount: 4,
+    },
+    {
+      sessionId: 's-sub-1',
+      parentSessionId: 's-top-1',
+      subagentType: 'explore',
+      description: 'explore subagent',
+      modified: t(-2000),
+      messageCount: 3,
+    },
+    {
+      sessionId: 's-sub-2',
+      parentSessionId: 's-top-1',
+      subagentType: 'plan',
+      description: 'plan subagent',
+      modified: t(-3000),
+      messageCount: 5,
+    },
+    {
+      sessionId: 's-sub-orphan',
+      parentSessionId: 's-missing-parent',
+      subagentType: 'review',
+      description: 'orphan subagent',
+      modified: t(-4000),
+      messageCount: 2,
+    },
+  ];
+
+  return {
+    projectPath,
+    sessions,
+    ...overrides,
+  };
+}
+
+module.exports = { setupSidebarDom, makeSampleProject };
diff --git a/test/dom-sidebar.test.js b/test/dom-sidebar.test.js
new file mode 100644
index 0000000..d7e4026
--- /dev/null
+++ b/test/dom-sidebar.test.js
@@ -0,0 +1,146 @@
+// Regression coverage for the two sidebar.js render-loop bugs we just
+// shipped:
+//
+//   1. `subagentIndex` was used in renderProjects() but not destructured
+//      from processProjectSessions()'s return — empty sidebar, hard error.
+//   2. `buildSessionsList(fId, visible, older, subagentIndex)` referenced
+//      `project.projectPath` for the orphan-toggle localStorage key, but
+//      `project` was out of scope — same blank sidebar.
+//
+// Both are "undefined identifier" bugs that the new ESLint config flags
+// statically. These tests are the runtime backstop: load sidebar.js into
+// jsdom, render a real project, and assert the resulting DOM matches
+// expectations. If either bug recurs, renderProjects() will throw before
+// any .session-item lands in #sidebar-content.
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { setupSidebarDom, makeSampleProject } = require('./dom-setup');
+
+test('renderProjects: structural completeness — no uncaught error, sessions land in sidebar', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const project = makeSampleProject();
+    // Both showArchived=false default — but archived sessions are still in
+    // project.sessions and end up in `older`/orphans; renderProjects must
+    // not throw regardless.
+    assert.doesNotThrow(() => ctx.sidebar.renderProjects([project], true),
+      'renderProjects() must not throw — regression for subagentIndex / projectPath');
+
+    const items = ctx.document.querySelectorAll('#sidebar-content .session-item');
+    assert.ok(items.length > 0, 'at least one .session-item must render');
+
+    // Top-level session 's-top-1' is rendered with id `si-s-top-1`.
+    const top1 = ctx.document.getElementById('si-s-top-1');
+    assert.ok(top1, 'top-level session item must be present');
+    assert.equal(top1.dataset.sessionId, 's-top-1');
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: starred + archived sessions both rendered, dataset.sessionId set', () => {
+  const ctx = setupSidebarDom();
+  try {
+    ctx.sidebar.renderProjects([makeSampleProject()], true);
+
+    const starred = ctx.document.querySelector('[data-session-id="s-top-1"] .session-pin.pinned');
+    assert.ok(starred, 'starred session must have .session-pin.pinned');
+
+    const archived = ctx.document.querySelector('[data-session-id="s-top-2"]');
+    assert.ok(archived, 'archived session is still rendered (filtered by showArchived flag elsewhere)');
+    assert.ok(archived.classList.contains('archived-item'), 'archived session has .archived-item class');
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: subagent child carets appear under parents', () => {
+  const ctx = setupSidebarDom();
+  try {
+    ctx.sidebar.renderProjects([makeSampleProject()], true);
+
+    // s-top-1 has 2 subagents (s-sub-1, s-sub-2). appendSubagentChildren
+    // adds a caret element with id `sub-caret-s-top-1`.
+    const caret = ctx.document.getElementById('sub-caret-s-top-1');
+    assert.ok(caret, 'subagent caret for s-top-1 must exist');
+    assert.match(caret.textContent, /2 subagents/);
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: orphan subagents (no matching parent) trigger orphan group', () => {
+  const ctx = setupSidebarDom();
+  try {
+    ctx.sidebar.renderProjects([makeSampleProject()], true);
+
+    // s-sub-orphan's parent is s-missing-parent → falls in the orphan
+    // group. This is exactly the codepath that broke in bug #2 (it reads
+    // project.projectPath for the localStorage key).
+    const orphanGroup = ctx.document.querySelector('.sidebar-orphan-subagents');
+    assert.ok(orphanGroup, 'orphan subagents group must be present when orphans exist');
+
+    const orphanLabel = orphanGroup.querySelector('.sidebar-orphan-label');
+    assert.ok(orphanLabel, 'orphan group has its label');
+    assert.match(orphanLabel.textContent, /Orphan subagents/);
+    const count = orphanGroup.querySelector('.orphan-count');
+    assert.equal(count?.textContent, '1', 'one orphan subagent counted');
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: orphan toggle uses projectPath in localStorage key (bug #2 regression)', () => {
+  const ctx = setupSidebarDom();
+  const projectPath = '/home/dev/myproj';
+  try {
+    ctx.sidebar.renderProjects([makeSampleProject({ projectPath })], true);
+
+    const orphanLabel = ctx.document.querySelector('.sidebar-orphan-label');
+    assert.ok(orphanLabel, 'orphan label present');
+
+    // Clicking the label toggles the collapsed state and writes the key.
+    // If `projectPath` were out of scope (bug #2), this would have thrown
+    // during render — but we also verify the write here for completeness.
+    orphanLabel.click();
+    const key = `orphanExpanded:${projectPath}`;
+    const value = ctx.window.localStorage.getItem(key);
+    assert.ok(value === '0' || value === '1', 'orphanExpanded localStorage key must be set after toggle');
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: empty project does not crash, sidebar stays empty', () => {
+  const ctx = setupSidebarDom();
+  try {
+    const empty = { projectPath: '/tmp/empty', sessions: [] };
+    assert.doesNotThrow(() => ctx.sidebar.renderProjects([empty], true));
+    const items = ctx.document.querySelectorAll('#sidebar-content .session-item');
+    assert.equal(items.length, 0);
+  } finally {
+    ctx.destroy();
+  }
+});
+
+test('renderProjects: result destructure is complete — re-render works (no stale closures)', () => {
+  // This test would have caught bug #1 directly: if renderProjects's
+  // destructure of processProjectSessions() result is incomplete and the
+  // missing var is then used downstream, the first call would throw
+  // ReferenceError. We render twice and check both yield a populated
+  // sidebar.
+  const ctx = setupSidebarDom();
+  try {
+    const project = makeSampleProject();
+    ctx.sidebar.renderProjects([project], true);
+    const first = ctx.document.querySelectorAll('#sidebar-content .session-item').length;
+    ctx.sidebar.renderProjects([project], false); // re-render preserving order
+    const second = ctx.document.querySelectorAll('#sidebar-content .session-item').length;
+    assert.ok(first > 0 && second > 0, 'both renders must populate the sidebar');
+    assert.equal(first, second, 'item count stable across re-renders');
+  } finally {
+    ctx.destroy();
+  }
+});
diff --git a/test/read-session-file.test.js b/test/read-session-file.test.js
new file mode 100644
index 0000000..17dbc03
--- /dev/null
+++ b/test/read-session-file.test.js
@@ -0,0 +1,219 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  readSessionFile,
+  subagentSessionId,
+  resolveJsonlPath,
+  readSubagentMeta,
+  enumerateSessionFiles,
+} = require('../read-session-file');
+
+function mkTmp() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'switchboard-rsf-'));
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+test('subagentSessionId formats parent and agent ids into the expected colon-delimited string', () => {
+  assert.equal(subagentSessionId('parent', 'agent'), 'sub:parent:agent');
+  const parent = '11111111-2222-3333-4444-555555555555';
+  const agent = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';
+  assert.equal(subagentSessionId(parent, agent), `sub:${parent}:${agent}`);
+  // Round-trip the prefix structure.
+  const id = subagentSessionId(parent, agent);
+  const parts = id.split(':');
+  assert.equal(parts[0], 'sub');
+  assert.equal(parts[1], parent);
+  assert.equal(parts[2], agent);
+});
+
+test('resolveJsonlPath returns top-level path when row has no parent/agent', () => {
+  const projectsDir = '/projects';
+  const row = { folder: 'foo', sessionId: 'session-1' };
+  assert.equal(resolveJsonlPath(projectsDir, row), path.join('/projects', 'foo', 'session-1.jsonl'));
+});
+
+test('resolveJsonlPath returns subagent path when parentSessionId and agentId are set', () => {
+  const projectsDir = '/projects';
+  const row = {
+    folder: 'foo',
+    sessionId: 'sub:parent-uuid:agent-1',
+    parentSessionId: 'parent-uuid',
+    agentId: 'agent-1',
+  };
+  assert.equal(
+    resolveJsonlPath(projectsDir, row),
+    path.join('/projects', 'foo', 'parent-uuid', 'subagents', 'agent-agent-1.jsonl')
+  );
+});
+
+test('readSubagentMeta reads sibling .meta.json when present and returns null when missing', () => {
+  const tmp = mkTmp();
+  try {
+    const jsonlPath = path.join(tmp, 'agent-x.jsonl');
+    const metaPath = path.join(tmp, 'agent-x.meta.json');
+    fs.writeFileSync(metaPath, JSON.stringify({ agentType: 'Explore', description: 'find things' }), 'utf8');
+    const meta = readSubagentMeta(jsonlPath);
+    assert.deepEqual(meta, { agentType: 'Explore', description: 'find things' });
+
+    const missing = readSubagentMeta(path.join(tmp, 'does-not-exist.jsonl'));
+    assert.equal(missing, null);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('enumerateSessionFiles discovers top-level sessions plus subagents and ignores junk', () => {
+  const tmp = mkTmp();
+  try {
+    // Top-level session
+    fs.writeFileSync(path.join(tmp, 'aaa.jsonl'), '', 'utf8');
+    // Subagents under preferred layout
+    const bbbSubagents = path.join(tmp, 'bbb', 'subagents');
+    fs.mkdirSync(bbbSubagents, { recursive: true });
+    fs.writeFileSync(path.join(bbbSubagents, 'agent-1.jsonl'), '', 'utf8');
+    fs.writeFileSync(path.join(bbbSubagents, 'agent-2.jsonl'), '', 'utf8');
+    // Fallback layout: jsonl directly in uuid dir
+    const cccDir = path.join(tmp, 'ccc');
+    fs.mkdirSync(cccDir);
+    fs.writeFileSync(path.join(cccDir, 'legacy.jsonl'), '', 'utf8');
+    // Junk that must be ignored
+    fs.writeFileSync(path.join(tmp, 'not-a-jsonl.txt'), 'noise', 'utf8');
+    fs.writeFileSync(path.join(tmp, 'bbb', 'random-file'), 'noise', 'utf8');
+
+    const entries = enumerateSessionFiles(tmp);
+    assert.equal(entries.length, 4, `expected 4 entries, got ${entries.length}: ${JSON.stringify(entries)}`);
+
+    const byId = new Map(entries.map(e => [e.sessionId, e]));
+
+    const top = byId.get('aaa');
+    assert.ok(top, 'expected aaa top-level entry');
+    assert.equal(top.parentSessionId, null);
+    assert.equal(top.filePath, path.join(tmp, 'aaa.jsonl'));
+
+    const a1 = byId.get('agent-1');
+    assert.ok(a1, 'expected agent-1 subagent entry');
+    assert.equal(a1.parentSessionId, 'bbb');
+    assert.equal(a1.filePath, path.join(bbbSubagents, 'agent-1.jsonl'));
+
+    const a2 = byId.get('agent-2');
+    assert.ok(a2, 'expected agent-2 subagent entry');
+    assert.equal(a2.parentSessionId, 'bbb');
+
+    const legacy = byId.get('legacy');
+    assert.ok(legacy, 'expected legacy fallback entry');
+    assert.equal(legacy.parentSessionId, 'ccc');
+    assert.equal(legacy.filePath, path.join(cccDir, 'legacy.jsonl'));
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('readSessionFile returns a top-level row when called without opts', () => {
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'plain-session';
+    const filePath = path.join(tmp, `${sessionId}.jsonl`);
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify({ type: 'user', message: 'hello world' }) + '\n',
+      'utf8'
+    );
+
+    const row = readSessionFile(filePath, 'folder-x', '/some/project');
+    assert.ok(row, 'expected a row');
+    assert.equal(row.sessionId, sessionId);
+    assert.equal(row.folder, 'folder-x');
+    assert.equal(row.projectPath, '/some/project');
+    assert.equal(row.summary, 'hello world');
+    assert.equal(row.messageCount, 1);
+    assert.equal(row.parentSessionId, undefined);
+    assert.equal(row.agentId, undefined);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('readSessionFile (subagent) returns synthetic id plus parent/agent metadata when sidechain present', () => {
+  const tmp = mkTmp();
+  try {
+    const parentSessionId = 'parent-uuid-abc';
+    const agentId = 'abc123';
+    const subagentsDir = path.join(tmp, parentSessionId, 'subagents');
+    fs.mkdirSync(subagentsDir, { recursive: true });
+    const filePath = path.join(subagentsDir, `agent-${agentId}.jsonl`);
+    const metaPath = path.join(subagentsDir, `agent-${agentId}.meta.json`);
+
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify({
+        type: 'user',
+        message: 'first prompt to subagent',
+        isSidechain: true,
+        agentId,
+      }) + '\n',
+      'utf8'
+    );
+    fs.writeFileSync(
+      metaPath,
+      JSON.stringify({ agentType: 'Explore', description: 'do a thing' }),
+      'utf8'
+    );
+
+    const row = readSessionFile(filePath, 'folder-x', '/some/project', { parentSessionId });
+    assert.ok(row, 'expected a subagent row');
+    assert.equal(row.sessionId, `sub:${parentSessionId}:${agentId}`);
+    assert.equal(row.parentSessionId, parentSessionId);
+    assert.equal(row.agentId, agentId);
+    assert.equal(row.subagentType, 'Explore');
+    assert.equal(row.description, 'do a thing');
+    // summary prefers description when meta provides one
+    assert.equal(row.summary, 'do a thing');
+    // firstPrompt holds the actual first user text
+    assert.equal(row.firstPrompt, 'first prompt to subagent');
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('readSessionFile (subagent) returns null when the file is not actually a sidechain', () => {
+  const tmp = mkTmp();
+  try {
+    const filePath = path.join(tmp, 'agent-foo.jsonl');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify({ type: 'user', message: 'looks normal', agentId: 'foo' }) + '\n',
+      'utf8'
+    );
+
+    const row = readSessionFile(filePath, 'folder-x', '/p', { parentSessionId: 'parent' });
+    assert.equal(row, null);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('readSessionFile (subagent) falls back to filename when agentId is absent in jsonl entries', () => {
+  const tmp = mkTmp();
+  try {
+    const filePath = path.join(tmp, 'agent-fallback.jsonl');
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify({ type: 'user', message: 'prompt', isSidechain: true }) + '\n',
+      'utf8'
+    );
+
+    const row = readSessionFile(filePath, 'folder-x', '/p', { parentSessionId: 'parent-1' });
+    assert.ok(row, 'expected a row even without inline agentId');
+    assert.equal(row.agentId, 'fallback');
+    assert.equal(row.sessionId, 'sub:parent-1:fallback');
+  } finally {
+    cleanup(tmp);
+  }
+});
diff --git a/test/session-transitions.test.js b/test/session-transitions.test.js
new file mode 100644
index 0000000..803c6af
--- /dev/null
+++ b/test/session-transitions.test.js
@@ -0,0 +1,248 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const sessionTransitions = require('../session-transitions');
+const { detectSubagentTransitions, init } = sessionTransitions;
+
+function mkTmp() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'switchboard-st-'));
+}
+
+function cleanup(dir) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+/** Build a mock mainWindow that records every webContents.send call. */
+function makeMockWindow() {
+  const events = [];
+  return {
+    isDestroyed: () => false,
+    webContents: {
+      send: (channel, payload) => events.push({ channel, payload }),
+    },
+    _events: events,
+  };
+}
+
+/** Initialize the module with mocks. Returns the recorded-events array.
+ *  Real stubs (read by detectSubagentTransitions): getMainWindow, log.
+ *  Unused-but-required-by-init: PROJECTS_DIR, activeSessions, rekeyMcpServer
+ *  (only consumed by detectSessionTransitions, which these tests don't exercise). */
+function setupModule() {
+  const win = makeMockWindow();
+  init({
+    PROJECTS_DIR: '/unused',
+    activeSessions: new Map(),
+    getMainWindow: () => win,
+    log: { info: () => {}, debug: () => {}, warn: () => {}, error: () => {} },
+    rekeyMcpServer: () => {},
+  });
+  return win._events;
+}
+
+/** Create N agent jsonl files under <folder>/<sessionId>/subagents/ and
+ *  set their mtimes to (anchor - ageMs). Returns the subagents dir. */
+function seedAgents(folder, sessionId, agents, anchor = Date.now()) {
+  const subDir = path.join(folder, sessionId, 'subagents');
+  fs.mkdirSync(subDir, { recursive: true });
+  for (const { id, ageMs = 0, content = '' } of agents) {
+    const filePath = path.join(subDir, `agent-${id}.jsonl`);
+    fs.writeFileSync(filePath, content, 'utf8');
+    if (ageMs) {
+      const t = (anchor - ageMs) / 1000;
+      fs.utimesSync(filePath, t, t);
+    }
+  }
+  return subDir;
+}
+
+test('bootstrap call with 5 pre-existing subagents emits zero events and populates the map', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent-session';
+    const now = Date.now();
+    seedAgents(tmp, sessionId, [
+      { id: 'a1' }, { id: 'a2' }, { id: 'a3' }, { id: 'a4' }, { id: 'a5' },
+    ], now);
+
+    const session = {}; // knownSubagents undefined → bootstrap
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 0, 'bootstrap must not emit IPC');
+    assert.ok(session.knownSubagents instanceof Map);
+    assert.equal(session.knownSubagents.size, 5);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('bootstrap marks an old-mtime agent (>60s) as completed: true', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    seedAgents(tmp, sessionId, [{ id: 'oldie', ageMs: 120_000 }], now); // 2 minutes old
+
+    const session = {};
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 0);
+    const entry = session.knownSubagents.get('oldie');
+    assert.ok(entry, 'expected an entry for oldie');
+    assert.equal(entry.completed, true);
+    assert.ok(entry._completedAt, 'expected _completedAt to be stamped');
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('bootstrap marks a fresh-mtime agent as completed: false (lifecycle continues)', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    seedAgents(tmp, sessionId, [{ id: 'fresh', ageMs: 5_000 }], now); // 5s old, well under 60s
+
+    const session = {};
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 0, 'bootstrap must still be silent for fresh agents');
+    const entry = session.knownSubagents.get('fresh');
+    assert.ok(entry);
+    assert.equal(entry.completed, false);
+    assert.equal(entry._completedAt, null);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('post-bootstrap: a brand-new agent file emits exactly one subagent-spawned event', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    // First, bootstrap with empty subagents dir
+    fs.mkdirSync(path.join(tmp, sessionId, 'subagents'), { recursive: true });
+    const session = {};
+    detectSubagentTransitions(sessionId, session, tmp, now);
+    assert.equal(events.length, 0);
+    assert.equal(session.knownSubagents.size, 0);
+
+    // Now drop in a new agent file plus its sidecar .meta.json so the spawn
+    // IPC payload carries the real agentType/description through.
+    const subDir = seedAgents(tmp, sessionId, [{ id: 'newcomer' }], now);
+    fs.writeFileSync(
+      path.join(subDir, 'agent-newcomer.meta.json'),
+      JSON.stringify({ agentType: 'general-purpose', description: 'investigate the thing' }),
+      'utf8',
+    );
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 1, `expected 1 event, got ${events.length}`);
+    assert.equal(events[0].channel, 'subagent-spawned');
+    assert.equal(events[0].payload.parentSessionId, sessionId);
+    assert.equal(events[0].payload.agentId, 'newcomer');
+    assert.equal(events[0].payload.subagentType, 'general-purpose');
+    assert.equal(events[0].payload.description, 'investigate the thing');
+    assert.equal(session.knownSubagents.get('newcomer').completed, false);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('post-bootstrap with no new agents emits zero events (IPC-flood regression)', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    seedAgents(tmp, sessionId, [{ id: 'a' }, { id: 'b' }, { id: 'c' }], now);
+
+    const session = {};
+    // Bootstrap absorbs all three silently
+    detectSubagentTransitions(sessionId, session, tmp, now);
+    assert.equal(events.length, 0);
+
+    // Subsequent flushes with no new files must stay silent
+    detectSubagentTransitions(sessionId, session, tmp, now);
+    detectSubagentTransitions(sessionId, session, tmp, now);
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 0, 'no events should fire when nothing changed');
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('GC: a completed entry older than 5 minutes is purged from knownSubagents', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    // Create the subagents dir but leave it empty so the readdir succeeds.
+    // The agent's jsonl file is gone (cleanup after completion) but its
+    // entry still sits in the in-memory Map — that's the GC target.
+    fs.mkdirSync(path.join(tmp, sessionId, 'subagents'), { recursive: true });
+
+    const session = { knownSubagents: new Map() };
+    session.knownSubagents.set('ghost', {
+      mtimeMs: now - 10 * 60_000,
+      completed: true,
+      _completedAt: now - 6 * 60_000, // completed 6 minutes ago → past 5-min TTL
+    });
+    // Also seed one entry inside the TTL window to confirm it survives.
+    session.knownSubagents.set('keeper', {
+      mtimeMs: now - 60_000,
+      completed: true,
+      _completedAt: now - 60_000, // 1 minute ago → within TTL
+    });
+
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 0, 'GC must not emit IPC');
+    assert.equal(session.knownSubagents.has('ghost'), false, 'expected ghost to be purged');
+    assert.equal(session.knownSubagents.has('keeper'), true, 'expected keeper to survive');
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('completion: agent alive on call N, stable mtime for >30s on call N+1, emits subagent-completed', () => {
+  const events = setupModule();
+  const tmp = mkTmp();
+  try {
+    const sessionId = 'parent';
+    const now = Date.now();
+    const subDir = seedAgents(tmp, sessionId, [{ id: 'slow' }], now);
+    const filePath = path.join(subDir, 'agent-slow.jsonl');
+    const mtimeMs = fs.statSync(filePath).mtimeMs;
+
+    // Pre-seed knownSubagents as if a prior call already saw this agent alive
+    // and started the stability timer 31 seconds ago. This skips bootstrap mode
+    // since knownSubagents is already defined.
+    const session = { knownSubagents: new Map() };
+    session.knownSubagents.set('slow', {
+      mtimeMs, // same as file's actual mtime → "mtime stable"
+      completed: false,
+      _stableStart: now - 31_000, // stability started >30s ago
+    });
+
+    detectSubagentTransitions(sessionId, session, tmp, now);
+
+    assert.equal(events.length, 1, `expected 1 completion event, got ${events.length}: ${JSON.stringify(events)}`);
+    assert.equal(events[0].channel, 'subagent-completed');
+    assert.equal(events[0].payload.parentSessionId, sessionId);
+    assert.equal(events[0].payload.agentId, 'slow');
+    assert.equal(session.knownSubagents.get('slow').completed, true);
+  } finally {
+    cleanup(tmp);
+  }
+});
diff --git a/workers/scan-projects.js b/workers/scan-projects.js
index 62bd73a..2e37666 100644
--- a/workers/scan-projects.js
+++ b/workers/scan-projects.js
@@ -3,7 +3,7 @@ const fs = require('fs');
 const path = require('path');
 const { getFolderIndexMtimeMs } = require('../folder-index-state');
 const { deriveProjectPath } = require('../derive-project-path');
-const { readSessionFile } = require('../read-session-file');
+const { readSessionFile, enumerateSessionFiles } = require('../read-session-file');
 
 const PROJECTS_DIR = workerData.projectsDir;
 
@@ -14,13 +14,12 @@ function readFolderFromFilesystem(folder) {
   const sessions = [];
   const indexMtimeMs = getFolderIndexMtimeMs(folderPath);
 
-  try {
-    const jsonlFiles = fs.readdirSync(folderPath).filter(f => f.endsWith('.jsonl'));
-    for (const file of jsonlFiles) {
-      const s = readSessionFile(path.join(folderPath, file), folder, projectPath);
+  for (const { filePath, parentSessionId } of enumerateSessionFiles(folderPath)) {
+    try {
+      const s = readSessionFile(filePath, folder, projectPath, { parentSessionId });
       if (s) sessions.push(s);
-    }
-  } catch {}
+    } catch {}
+  }
 
   return { folder, projectPath, sessions, indexMtimeMs };
 }