diff --git a/desktop/package.json b/desktop/package.json
index 90178d1..28adc00 100644
--- a/desktop/package.json
+++ b/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "codbash-desktop",
   "productName": "codbash",
-  "version": "7.14.4",
+  "version": "7.14.5",
   "private": true,
   "description": "Desktop shell (Electron) for codbash — wraps the codbash server in a native window.",
   "main": "main.js",
diff --git a/package.json b/package.json
index 651c53f..e593dfd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "codbash-app",
-  "version": "7.14.4",
+  "version": "7.14.5",
   "description": "Dashboard + CLI for AI coding agents — Claude Code, Codex, Cursor, OpenCode, Kiro. View, search, resume, convert, sync sessions.",
   "bin": {
     "codbash": "./bin/cli.js",
diff --git a/src/changelog.js b/src/changelog.js
index 50e6f47..3daff8e 100644
--- a/src/changelog.js
+++ b/src/changelog.js
@@ -1,6 +1,21 @@
 'use strict';
 
 const CHANGELOG = [
+  {
+    version: '7.14.5',
+    date: '2026-07-20',
+    title: 'Bug-hunt sweep: crash-safety, data-loss fix, and many correctness fixes',
+    changes: [
+      'Server no longer crashes on a malformed session id (e.g. /api/session/__proto__); read routes are prototype-safe and every route now returns 500 instead of taking down the process',
+      'Import now truly merges history — it no longer overwrites your local Claude/Codex history before dedup (previously local sessions could be lost)',
+      'Fixed WSL terminal launch (a ReferenceError broke every launch on WSL)',
+      'Delete / bulk-delete now validate the session id; archive tar calls no longer go through a shell (path-injection safe)',
+      'Cost totals for a running session now update instead of freezing at first read; Copilot sessions are now included in full-text search',
+      'Live badges reappear after navigating; keyboard navigation works in List layout; the Agent Board refreshes on activity; a tool filter no longer stays highlighted after you toggle it off',
+      'Delete during an Escape no longer shows a false failure; pressing Escape while renaming a terminal tab now cancels instead of committing',
+      'Claude session first/last timestamps, IPv6 loopback access, ~ in a terminal cwd, Codex export assistant blocks, and the handoff "Original Task" section all fixed',
+    ],
+  },
   {
     version: '7.14.4',
     date: '2026-07-20',
diff --git a/src/convert.js b/src/convert.js
index c71d892..4e4053b 100644
--- a/src/convert.js
+++ b/src/convert.js
@@ -236,7 +236,9 @@ function writeCodex(canonical, targetProject) {
       payload: {
         type: 'message',
         role: msg.role,
-        content: [{ type: 'input_text', text: msg.content }],
+        // Codex tags assistant turns as output_text and user turns as
+        // input_text; using input_text for everything makes malformed rollouts.
+        content: [{ type: msg.role === 'assistant' ? 'output_text' : 'input_text', text: msg.content }],
       },
     }));
   }
diff --git a/src/data.js b/src/data.js
index b7f6842..591ca1f 100644
--- a/src/data.js
+++ b/src/data.js
@@ -931,9 +931,13 @@ function parseClaudeSessionFile(sessionFile) {
       if (entry.type === 'user' || entry.type === 'assistant') msgCount++;
       if (entry.type === 'user') totalUserMsgs++;
       if (isRealUserPrompt(entry)) userMsgCount++;
-      if (entry.timestamp) {
-        if (entry.timestamp < firstTs) firstTs = entry.timestamp;
-        if (entry.timestamp > lastTs) lastTs = entry.timestamp;
+      // entry.timestamp is an ISO 8601 string; firstTs/lastTs are ms numbers
+      // (init'd to stat.mtimeMs). Comparing string<number is always NaN-false,
+      // so normalize to ms first or the min/max never updates from the entries.
+      var entryTs = parseEntryTimestampMs(entry);
+      if (Number.isFinite(entryTs)) {
+        if (entryTs < firstTs) firstTs = entryTs;
+        if (entryTs > lastTs) lastTs = entryTs;
       }
       if (!projectPath && entry.type === 'user' && entry.cwd) {
         projectPath = entry.cwd;
@@ -4092,8 +4096,13 @@ function _buildSessionFileIndex() {
 function findSessionFile(sessionId, project) {
   _buildSessionFileIndex();
 
-  // Fast index lookup
-  if (_sessionFileIndex[sessionId]) return _sessionFileIndex[sessionId];
+  // Fast index lookup. Use hasOwnProperty so a prototype key like '__proto__'
+  // or 'constructor' can't return Object.prototype (a truthy non-record) and
+  // crash callers that then read .file/.format off it.
+  if (typeof sessionId === 'string' &&
+      Object.prototype.hasOwnProperty.call(_sessionFileIndex, sessionId)) {
+    return _sessionFileIndex[sessionId];
+  }
 
   // Try Claude projects dir (direct path if project known)
   if (project) {
@@ -4731,6 +4740,17 @@ function buildSearchIndex(sessions) {
             texts.push({ role: msg.role, content: msg.content.slice(0, 500) });
           }
         }
+      } else if (found.format === 'copilot-chat' || found.format === 'copilot') {
+        // Copilot Chat (VS Code JSON) and Copilot CLI use bespoke loaders; the
+        // generic JSONL branch below would mis-parse them and index nothing.
+        const detail = found.format === 'copilot'
+          ? loadCopilotCliDetail(s.id)
+          : loadCopilotDetail(s.id);
+        for (const msg of (detail.messages || [])) {
+          if (msg.content && !isSystemMessage(msg.content)) {
+            texts.push({ role: msg.role, content: msg.content.slice(0, 500) });
+          }
+        }
       } else {
         const lines = readLines(found.file);
 
@@ -5003,8 +5023,6 @@ const EMPTY_COST = {
 const _costMemCache = {};
 
 function computeSessionCost(sessionId, project) {
-  if (_costMemCache[sessionId] !== undefined) return _costMemCache[sessionId];
-
   const found = findSessionFile(sessionId, project);
   if (!found) { _costMemCache[sessionId] = EMPTY_COST; return EMPTY_COST; }
 
@@ -5031,6 +5049,11 @@ function computeSessionCost(sessionId, project) {
       } catch {}
     }
   }
+  // In-memory fast layer, keyed by the SAME fingerprint as the disk cache
+  // (file+mtime+size) — NOT by sessionId — so a still-growing session's cost is
+  // recomputed on change instead of frozen at its first read.
+  const memKey = cacheKey || ('sid:' + sessionId);
+  if (_costMemCache[memKey] !== undefined) return _costMemCache[memKey];
   if (cacheKey && _costDiskCache[cacheKey]) return _costDiskCache[cacheKey];
 
   let totalCost = 0;
@@ -5260,7 +5283,7 @@ function computeSessionCost(sessionId, project) {
       unavailable,
     };
     if (cacheKey) _costDiskCache[cacheKey] = result;
-    _costMemCache[sessionId] = result;
+    _costMemCache[memKey] = result;
     return result;
   }
 
@@ -5328,7 +5351,7 @@ function computeSessionCost(sessionId, project) {
     unavailable,
   };
   if (cacheKey) _costDiskCache[cacheKey] = result;
-  _costMemCache[sessionId] = result;
+  _costMemCache[memKey] = result;
   return result;
 }
 
diff --git a/src/frontend/app.js b/src/frontend/app.js
index fbaeb04..2e2917c 100644
--- a/src/frontend/app.js
+++ b/src/frontend/app.js
@@ -1170,10 +1170,12 @@ async function pollActiveSessions() {
       }
     });
 
-    // Check if anything changed — skip DOM work if not
+    // Check if anything changed — skip DOM work if not. Note: _prevActiveKey is
+    // set at the END of this function, not here, because render() (invoked below
+    // for the running view, and elsewhere on navigation) resets it to '' to force
+    // a badge re-apply; setting it last means that reset can't spin a re-render.
     var newKey = data.map(function(a) { return (a.sessionId || a.pid) + ':' + a.status; }).sort().join(',');
     if (newKey === _prevActiveKey) return;
-    _prevActiveKey = newKey;
 
     activeSessions = newActive;
 
@@ -1181,6 +1183,9 @@ async function pollActiveSessions() {
     // the sidebar running-agents tree (which is driven by activeSessions now).
     if (typeof _ovRefreshIfCurrent === 'function') _ovRefreshIfCurrent();
     if (typeof _wsRenderRunningTree === 'function') _wsRenderRunningTree();
+    // The Running (Agent Board) view is built from activeSessions but isn't a
+    // per-card diff, so rebuild it when the active set changes.
+    if (currentView === 'running') render();
 
     // Only touch cards that changed
     document.querySelectorAll('.card').forEach(function(card) {
@@ -1232,6 +1237,10 @@ async function pollActiveSessions() {
         }
       }
     });
+
+    // Record the applied state last, so a render()-triggered reset above is
+    // superseded and the next unchanged poll can early-return.
+    _prevActiveKey = newKey;
   } catch {}
 }
 
@@ -1655,6 +1664,11 @@ function render() {
   // AI Titles/Refresh + count) is meaningless in the Terminal and Overview views.
   document.body.setAttribute('data-view', currentView);
 
+  // Rebuilding content wipes the live/active badges the active-poll diff added.
+  // Reset the diff key so the next poll re-applies them (it otherwise early-
+  // returns on an unchanged active set and the badges never come back).
+  _prevActiveKey = '';
+
   // Detach (don't destroy) the live terminal when navigating away from the
   // Workspace view: its panes/ptys keep running in a hidden holder and are
   // re-attached intact on return.
@@ -2391,16 +2405,20 @@ function closeConfirm() {
 
 async function confirmDelete() {
   if (!pendingDelete) return;
+  // Capture the target now: pendingDelete is a mutable global that Escape
+  // (closeConfirm) nulls, so reading it after the awaits below would throw and
+  // surface a false "Delete failed" if the user dismissed mid-request.
+  var target = pendingDelete;
   try {
-    var resp = await fetch('/api/session/' + pendingDelete.id, {
+    var resp = await fetch('/api/session/' + target.id, {
       method: 'DELETE',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ project: pendingDelete.project })
+      body: JSON.stringify({ project: target.project })
     });
     var data = await resp.json();
     if (data.ok) {
       showToast('Session deleted');
-      allSessions = allSessions.filter(function(s) { return s.id !== pendingDelete.id; });
+      allSessions = allSessions.filter(function(s) { return s.id !== target.id; });
       // Clear search if no more results
       if (searchQuery) {
         var remaining = allSessions.filter(function(s) {
@@ -2908,7 +2926,7 @@ function isInput(e) {
 }
 
 function moveFocus(delta) {
-  var cards = document.querySelectorAll('.card');
+  var cards = document.querySelectorAll('.card, .list-row');
   if (cards.length === 0) return;
   focusedIndex = Math.max(0, Math.min(cards.length - 1, focusedIndex + delta));
   cards.forEach(function(c, i) {
@@ -2920,7 +2938,7 @@ function moveFocus(delta) {
 }
 
 function openFocusedCard() {
-  var cards = document.querySelectorAll('.card');
+  var cards = document.querySelectorAll('.card, .list-row');
   if (focusedIndex < 0 || focusedIndex >= cards.length) return;
   var id = cards[focusedIndex].getAttribute('data-id');
   if (!id) return;
@@ -2935,14 +2953,14 @@ function openFocusedCard() {
 }
 
 function toggleStarFocused() {
-  var cards = document.querySelectorAll('.card');
+  var cards = document.querySelectorAll('.card, .list-row');
   if (focusedIndex < 0 || focusedIndex >= cards.length) return;
   var id = cards[focusedIndex].getAttribute('data-id');
   if (id) toggleStar(id);
 }
 
 function deleteFocused() {
-  var cards = document.querySelectorAll('.card');
+  var cards = document.querySelectorAll('.card, .list-row');
   if (focusedIndex < 0 || focusedIndex >= cards.length) return;
   var id = cards[focusedIndex].getAttribute('data-id');
   if (!id) return;
diff --git a/src/frontend/calendar.js b/src/frontend/calendar.js
index 4bf602f..f6f5a46 100644
--- a/src/frontend/calendar.js
+++ b/src/frontend/calendar.js
@@ -236,9 +236,14 @@ function setView(view) {
   // Update sidebar active state
   document.querySelectorAll('.sidebar-item').forEach(function(el) {
     var itemView = el.getAttribute('data-view');
-    var active = itemView === view;
+    var active;
+    // Tool-filter items are toggles: derive their highlight from the actual
+    // filter state, not `itemView === view` (which stays true after toggling
+    // the filter OFF, leaving the item wrongly highlighted).
     if (itemView === 'pi-original-only') active = toolFilter === 'pi' && piVariantFilter === 'pi';
     else if (itemView === 'ohmypi-only') active = toolFilter === 'pi' && piVariantFilter === 'ohmypi';
+    else if (itemView && itemView.slice(-5) === '-only') active = toolFilter === itemView.slice(0, -5);
+    else active = itemView === view;
     el.classList.toggle('active', active);
   });
 
diff --git a/src/frontend/workspace.js b/src/frontend/workspace.js
index 1ca8730..37a91d1 100644
--- a/src/frontend/workspace.js
+++ b/src/frontend/workspace.js
@@ -113,7 +113,9 @@ function _wsUpdateStatusBar() {
     // The chip shows the (renamable) tab name only — clean and stable. The
     // command lands in the tooltip so it never makes the bar jitter.
     var tip = (x.pane.cwd || '') + (x.pane.cmd ? '  —  ' + _wsMaskSecrets(x.pane.cmd) : '');
-    sigParts.push(x.tab.id + ':' + x.pane.id + ':' + x.tab.name + ':' + st);
+    // Include `tip` in the signature: without it a cwd/cmd change with an
+    // unchanged tab name + status would skip the rebuild and leave a stale tooltip.
+    sigParts.push(x.tab.id + ':' + x.pane.id + ':' + x.tab.name + ':' + st + ':' + tip);
     return '<button class="ws-chip ' + meta.cls + '" title="' + escHtml(tip) + '" ' +
       'onclick="jumpToWorkspacePane(\'' + escHtml(x.tab.id) + '\',\'' + escHtml(x.pane.id) + '\')">' +
       '<span class="ws-chip-dot"></span>' + escHtml(x.tab.name) +
@@ -689,14 +691,26 @@ function renameWorkspaceTab(id) {
   input.value = tab.name;
   el.replaceWith(input);
   input.focus(); input.select();
+  // `done` guards against the blur handler re-firing after we remove the input:
+  // both Enter (commit → re-render removes input → blur) and Escape (cancel →
+  // re-render removes input → blur) would otherwise commit a second time. Escape
+  // must NOT commit at all.
+  var done = false;
   function commit() {
+    if (done) return;
+    done = true;
     var v = input.value.trim();
     if (v) { tab.name = v; tab.userNamed = true; }   // manual name wins over auto-naming
     _wsRenderTabbar();
   }
+  function cancel() {
+    if (done) return;
+    done = true;
+    _wsRenderTabbar();
+  }
   input.addEventListener('keydown', function (e) {
     if (e.key === 'Enter') { e.preventDefault(); commit(); }
-    else if (e.key === 'Escape') { _wsRenderTabbar(); }
+    else if (e.key === 'Escape') { e.preventDefault(); cancel(); }
   });
   input.addEventListener('blur', commit);
   input.addEventListener('click', function (e) { e.stopPropagation(); });
diff --git a/src/handoff.js b/src/handoff.js
index cda523a..2cb5615 100644
--- a/src/handoff.js
+++ b/src/handoff.js
@@ -22,9 +22,11 @@ function generateHandoff(sessionId, project, options) {
   const session = sessions.find(s => s.id === sessionId || s.id.startsWith(sessionId));
   if (!session) return { ok: false, error: 'Session not found' };
 
-  // Load messages
+  // Load messages. `allMessages` is the full session (used for the genuine
+  // first task); `messages` is the recent-window tail used for the transcript.
   const detail = loadSessionDetail(session.id, session.project || project);
-  const messages = (detail.messages || []).slice(-msgLimit);
+  const allMessages = detail.messages || [];
+  const messages = allMessages.slice(-msgLimit);
   const cost = computeSessionCost(session.id, session.project || project);
   const costLabel = cost.unavailable
     ? `unavailable (${cost.model || 'unknown model'})`
@@ -42,8 +44,10 @@ function generateHandoff(sessionId, project, options) {
 
   // Summary of what was being worked on
   if (messages.length > 0) {
-    // First user message = original task
-    const firstUser = messages.find(m => m.role === 'user');
+    // Original task = the FIRST user message of the whole session, not merely
+    // the first within the truncated recent window (which mislabels the task
+    // for any session longer than msgLimit).
+    const firstUser = allMessages.find(m => m.role === 'user');
     if (firstUser) {
       lines.push('## Original Task');
       lines.push('');
diff --git a/src/migrate.js b/src/migrate.js
index 7fd33c8..05f5a7b 100644
--- a/src/migrate.js
+++ b/src/migrate.js
@@ -3,11 +3,37 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 
 const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 const CODEX_DIR = path.join(os.homedir(), '.codex');
 
+// Read a .jsonl file into a line array (missing/unreadable → []).
+function readJsonlLines(file) {
+  try { return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean); }
+  catch { return []; }
+}
+
+// Merge a just-extracted history.jsonl with the lines that were present locally
+// BEFORE extraction (which overwrote the file), deduped by sessionId+timestamp.
+// `priorLines` come first so local entries win on tie. Without this, import
+// silently discards the machine's own history despite the "merge" promise.
+function mergeHistoryFile(file, priorLines) {
+  const merged = priorLines.concat(readJsonlLines(file));
+  if (!merged.length) return;
+  const seen = new Set();
+  const out = [];
+  for (const line of merged) {
+    let key;
+    try { const d = JSON.parse(line); key = d.sessionId + ':' + d.timestamp; }
+    catch { key = 'raw:' + line; }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(line);
+  }
+  fs.writeFileSync(file, out.join('\n') + '\n');
+}
+
 function exportArchive(outPath) {
   const absOut = path.resolve(outPath);
 
@@ -97,10 +123,12 @@ function exportArchive(outPath) {
   console.log('');
   console.log('  Creating archive...');
 
-  // Create tar.gz from home directory
-  const pathArgs = paths.map(p => `"${p}"`).join(' ');
+  // Create tar.gz from home directory. execFileSync with an argument array
+  // (not a shell string) so an output path containing quotes/backticks/$ can't
+  // break quoting or inject a command.
   try {
-    execSync(`cd "${os.homedir()}" && tar -czf "${absOut}" ${pathArgs}`, {
+    execFileSync('tar', ['-czf', absOut, ...paths], {
+      cwd: os.homedir(),
       stdio: 'pipe',
     });
     const archiveSize = fs.statSync(absOut).size;
@@ -128,9 +156,9 @@ function importArchive(archivePath) {
   console.log('  \x1b[36m\x1b[1mCodBash Import\x1b[0m');
   console.log(`  Archive: ${absPath}`);
 
-  // List contents
-  const contents = execSync(`tar -tzf "${absPath}" | head -20`, { encoding: 'utf8' }).trim();
-  const lines = contents.split('\n');
+  // List contents (execFileSync — no shell, so the archive path is safe).
+  const contents = execFileSync('tar', ['-tzf', absPath], { encoding: 'utf8' }).trim();
+  const lines = contents.split('\n').slice(0, 20);
   const dirs = lines.map(l => l.split('/')[0]).filter((v,i,a) => a.indexOf(v) === i);
 
   console.log(`  Contains: ${dirs.join(', ')}`);
@@ -143,35 +171,26 @@ function importArchive(archivePath) {
 
   if (hasExisting) {
     console.log('  \x1b[33mWarning:\x1b[0m Existing session data found.');
-    console.log('  Import will \x1b[1mmerge\x1b[0m — existing files will be overwritten.');
+    console.log('  History files are \x1b[1mmerged\x1b[0m (deduped); other files are overwritten.');
     console.log('');
   }
 
-  // Extract to home directory
+  const claudeHistory = path.join(CLAUDE_DIR, 'history.jsonl');
+  const codexHistory = path.join(CODEX_DIR, 'history.jsonl');
+  // Stash the local history lines BEFORE extraction — tar will overwrite these
+  // files, so we must capture them now to merge them back afterwards.
+  const priorClaude = readJsonlLines(claudeHistory);
+  const priorCodex = readJsonlLines(codexHistory);
+
+  // Extract to home directory (execFileSync — no shell, path-injection safe).
   try {
-    execSync(`cd "${os.homedir()}" && tar -xzf "${absPath}"`, { stdio: 'pipe' });
-
-    // Merge history.jsonl if both exist
-    const importedHistory = path.join(CLAUDE_DIR, 'history.jsonl');
-    if (fs.existsSync(importedHistory)) {
-      // Deduplicate by sessionId+timestamp
-      const lines = fs.readFileSync(importedHistory, 'utf8').split('\n').filter(Boolean);
-      const seen = new Set();
-      const deduped = [];
-      for (const line of lines) {
-        try {
-          const d = JSON.parse(line);
-          const key = d.sessionId + ':' + d.timestamp;
-          if (!seen.has(key)) {
-            seen.add(key);
-            deduped.push(line);
-          }
-        } catch {
-          deduped.push(line);
-        }
-      }
-      fs.writeFileSync(importedHistory, deduped.join('\n') + '\n');
-    }
+    execFileSync('tar', ['-xzf', absPath], { cwd: os.homedir(), stdio: 'pipe' });
+
+    // Merge both history files with what was here before, so the machine's own
+    // sessions survive the import (previously Claude history was overwritten
+    // then only self-deduped, and Codex history was overwritten with no merge).
+    mergeHistoryFile(claudeHistory, priorClaude);
+    mergeHistoryFile(codexHistory, priorCodex);
 
     console.log('  \x1b[32mImport complete!\x1b[0m');
     console.log('  Run \x1b[2mcodbash run\x1b[0m to see your sessions.');
diff --git a/src/server.js b/src/server.js
index 2606588..f47677a 100644
--- a/src/server.js
+++ b/src/server.js
@@ -68,7 +68,13 @@ function startServer(host, port, openBrowser = true) {
   const allowedHosts = new Set(['localhost', '127.0.0.1', '::1', '[::1]']);
   const server = http.createServer((req, res) => {
     if (isLoopbackBind) {
-      const hostName = String(req.headers.host || '').toLowerCase().split(':')[0];
+      // IPv6-aware: a bracketed host like "[::1]:3847" must keep the "[::1]"
+      // group, not split at the first ':' (which would yield "[" and 403 a
+      // legitimate IPv6 loopback request).
+      const rawHost = String(req.headers.host || '').toLowerCase();
+      const hostName = rawHost.startsWith('[')
+        ? rawHost.slice(0, rawHost.indexOf(']') + 1)
+        : rawHost.split(':')[0];
       if (hostName && !allowedHosts.has(hostName)) {
         res.writeHead(403, { 'Content-Type': 'text/plain' });
         res.end('Forbidden: host header must be localhost');
@@ -81,6 +87,9 @@ function startServer(host, port, openBrowser = true) {
     const pathname = parsed.pathname;
     const reqStart = Date.now();
 
+    // A synchronous throw in any route (e.g. a malformed id reaching fs.*) must
+    // return 500 — it must never crash the single-process dashboard.
+    try {
     // Log all API requests (skip static & frequent polls)
     const isApi = pathname.startsWith('/api/');
     const isFrequent = pathname === '/api/active' || pathname === '/api/version';
@@ -396,7 +405,11 @@ function startServer(host, port, openBrowser = true) {
 
     // ── Delete ──────────────────────────────
     else if (req.method === 'DELETE' && pathname.startsWith('/api/session/')) {
-      const sessionId = pathname.split('/').pop();
+      const sessionId = decodeURIComponent(pathname.split('/').pop());
+      if (!SAFE_SESSION_ID.test(sessionId)) {
+        json(res, { ok: false, error: 'invalid session id' }, 400);
+        return;
+      }
       readBody(req, body => {
         try {
           const { project } = JSON.parse(body || '{}');
@@ -413,8 +426,13 @@ function startServer(host, port, openBrowser = true) {
       readBody(req, body => {
         try {
           const { sessions } = JSON.parse(body); // [{id, project}, ...]
+          if (!Array.isArray(sessions)) throw new Error('sessions must be an array');
           const results = [];
           for (const s of sessions) {
+            if (!s || typeof s.id !== 'string' || !SAFE_SESSION_ID.test(s.id)) {
+              results.push({ id: s && s.id, deleted: false, error: 'invalid session id' });
+              continue;
+            }
             const deleted = deleteSession(s.id, s.project || '');
             results.push({ id: s.id, deleted });
           }
@@ -903,6 +921,13 @@ function startServer(host, port, openBrowser = true) {
       res.writeHead(404);
       res.end('Not found');
     }
+    } catch (e) {
+      log('ERROR', `Route ${req.method} ${pathname} threw: ${(e && e.stack) || e}`);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'internal error' }));
+      }
+    }
   });
 
   // ── Browser terminal WebSocket (Workspace) ──
diff --git a/src/terminal.js b/src/terminal.js
index d72e218..626ffc5 100644
--- a/src/terminal.js
+++ b/src/terminal.js
@@ -172,8 +172,14 @@ function sendClose(socket) {
 // server so we reuse the dashboard's known-git-roots trust boundary.
 function resolveCwd(url, isSafeCwd) {
   const requested = url.searchParams.get('cwd');
-  if (requested && typeof isSafeCwd === 'function' && isSafeCwd(requested)) {
-    return requested;
+  // Expand a leading ~ before the safety check AND before handing the path to
+  // pty.spawn — a shell won't expand ~ in a cwd, so a raw "~/foo" spawns ENOENT.
+  const expanded = !requested ? requested
+    : requested === '~' ? os.homedir()
+    : requested.startsWith('~/') ? os.homedir() + requested.slice(1)
+    : requested;
+  if (expanded && typeof isSafeCwd === 'function' && isSafeCwd(expanded)) {
+    return expanded;
   }
   return os.homedir();
 }
diff --git a/src/terminals.js b/src/terminals.js
index 1bd36d5..76f25b0 100644
--- a/src/terminals.js
+++ b/src/terminals.js
@@ -348,7 +348,7 @@ function openInTerminal(sessionId, tool, flags, projectDir, terminalId, mode, co
     }
   } else if (platform === 'linux' && isWSL()) {
     let effectiveSessionId = sessionId;
-    if (fresh) {
+    if (mode === 'fresh') {
       // No session yet — generate a placeholder so window tagging still works.
       effectiveSessionId = 'fresh-' + Date.now().toString(36);
     } else {