@bakapiano/ccsm 0.2.0 → 0.4.0

package/CLAUDE.md

@@ -20,7 +20,7 @@ Then open http://localhost:7777.
 Default port `7777`, default workDir `~/ccsm-workspaces`. Config + snapshots live at `~/.ccsm/` (override with `CCSM_HOME=<path>`). All settings editable through the Config panel (`~/.ccsm/config.json` on disk). Notable knobs:
 
 - `port` (default `7777`) — preferred listen port. If taken, ccsm tries `+1..+9` then asks the OS for any free port. The startup log prints the actual URL so you always see where it ended up.
-- `autoOpenBrowser` (default true) — after `listen()` succeeds, ccsm spawns `cmd /c start "" <url>` to open the UI in the default browser. Disable for headless / nohup setups.
+- `browserMode` (default `app`) — how to open the UI on server start. `app` finds Edge or Chrome and spawns it with `--app=<url> --user-data-dir=<DATA_DIR>/browser-profile` for a chromeless webview-style window (no tabs, no address bar). `tab` opens the default browser as a regular tab. `none` skips opening. Legacy `autoOpenBrowser: false` still maps to `none` for back-compat.
 - `claudeCommand` (default `"claude"`) — what gets `--resume`'d or freshly invoked inside the new terminal. Can be an exe (`claude`, `claude.exe`), a PowerShell alias or function (`ccp`), or any wrapper script — see `commandShell` below.
 - `terminal` — `wt` | `powershell` | `pwsh` | `cmd`. wt opens a fresh window per launch (`wt -w new` is set to defeat the "fold into existing window" setting some users have). The other three each spawn via `cmd /c start ... <shell>`.
 - `commandShell` (default `pwsh`) — only consulted when `terminal=wt`. Values `pwsh` / `powershell` wrap `claudeCommand` inside `<shell> -NoExit -NoLogo -Command "Set-Location ...; & '<cmd>' '<args>'..."` so PowerShell aliases / functions / profile-defined names (like `ccp` from `$PROFILE`) resolve. `none` runs the command directly via wt (raw `CreateProcess`) — fine if `claudeCommand` is an actual exe on PATH, broken for aliases. `pwsh` / `powershell` kinds already wrap natively so this knob doesn't affect them; `cmd` kind has no shell concept for aliases.
@@ -88,7 +88,8 @@ The alternative ("one repo per workspace") was explicitly rejected — don't ref
 | POST | `/api/sessions/new` | body `{repos, workspace?, launch?}` — picks/creates ws, clones missing repos, launches wt |
 | POST | `/api/sessions/finder` | opens a wt with `claude` in `D:\ccsm` and the `finderPrompt` as opening message |
 | POST | `/api/sessions/:id/resume` | body `{cwd}` — launches `wt -d <cwd> claude --resume <id>` |
-| POST | `/api/sessions/:id/focus` | walks up the claude PID parent chain to find the wt window, raises it via SetForegroundWindow |
+| GET | `/api/sessions/recent` | recently-used sessions discovered from `~/.claude/projects/*/*.jsonl` mtimes, excluding currently-live ids |
+| POST | `/api/sessions/:id/focus` | matches a wt window by title (cleaned of leading status glyphs) against the session's ai-title; falls back to PID-parent walk if no unique match |
 | GET | `/api/terminals` | enumerate built-in terminal kinds + their process names |
 | GET | `/api/health` | sanity ping |
 
@@ -112,6 +113,8 @@ ccsm uses variant 1 and always `path.resolve()`s the cwd first — defends again
 
 **Don't test wt launching via `node -e "..."` inside `bash -c`.** Backslashes get eaten by shell quoting and the JS string ends up malformed. Write a `.js` file and `node file.js` instead.
 
+**focusBySession — title-based wt window matching.** Walking up the claude.exe PID parent chain and taking `MainWindowHandle` of the wt process *always* returns the same canonical window in modern multi-window single-process wt — clicking different sessions all focused the same window. `focusBySession` instead lists all visible wt windows (`EnumWindows` filtered by process name), strips the leading wt status glyph (`✳ `, `⠐ `, `⠠ ` …) and compares to the session's ai-title. Falls back to title-substring, then cwd-basename, then the old PID-parent walk when no unique match — at least the user sees *some* wt window even if it's the wrong tab. Caveat: for sessions sitting in an inactive tab of a multi-tab wt window, the window title shows the *active* tab's title — so we can't find them by title alone and the fallback is wrong-tab.
+
 **Focus helper (`lib/focus.js`).** One `powershell.exe -EncodedCommand <base64>` invocation per call, dispatched by `CCSM_FOCUS_MODE` env var into modes `list` (enumerate visible top-level windows owned by a process name), `focus-hwnd` (activate a specific HWND), `focus-pid` (walk parent chain to MainWindowHandle then activate). Encoded as UTF-16-LE-base64 — passing the C# block via stdin to `-Command -` silently produces no output, so we don't. Three gotchas baked in:
 1. C# `out _` discard breaks PowerShell 5.1's bundled C# compiler — use a named `uint dummy`.
 2. Windows blocks background processes from `SetForegroundWindow` — synthesize an Alt-key down/up via `keybd_event 0x12` first ("Alt-key trick") to qualify our process. Without it, `activated` returns false even though the window is found.

package/lib/config.js

@@ -22,7 +22,10 @@ const DEFAULTS = {
   terminal: 'wt',
   commandShell: 'pwsh',
   autoFocusOnLaunch: true,
-  autoOpenBrowser: true,
+  // 'app'  — Edge/Chrome --app=<url> chromeless window (looks like a desktop app)
+  // 'tab'  — open in default browser as a normal tab
+  // 'none' — don't open anything
+  browserMode: 'app',
   // Add the repos you most often need on hand. The "new session" button
   // clones any selected entries into the workspace before launching claude.
   // Example shape:

package/lib/focus.js

@@ -192,6 +192,63 @@ async function focusByPid(pid) {
   return await runPsHelper('focus-pid', n);
 }
 
+// Strip the leading wt status glyph + whitespace ("✳ ", "⠐ ", "⠠ " etc) so
+// the title compares cleanly. wt prefixes the tab title with a Braille-style
+// progress glyph or a sparkle/asterisk depending on activity.
+function cleanWtTitle(t) {
+  return String(t || '').replace(/^[^\w一-鿿]+/, '').trim();
+}
+
+// Best-effort: focus the wt window that belongs to a specific session.
+// Modern wt is single-process multi-window, so walking from claude.exe PID
+// up to wt.exe + taking MainWindowHandle always returns the same canonical
+// window regardless of which tab the session is actually in. Instead we
+// list all wt windows and match by tab title against the session's AI
+// title / cwd basename.
+async function focusBySession({ pid, sessionId, title, cwd }) {
+  const procName = 'WindowsTerminal.exe';
+  const cands = await listWindowsOf(procName);
+
+  const cleanedTitle = title ? cleanWtTitle(title) : '';
+  const cwdBase = cwd ? require('node:path').basename(cwd) : '';
+
+  // 1. Exact match on cleaned ai-title
+  if (cleanedTitle) {
+    const exact = cands.filter((w) => cleanWtTitle(w.title) === cleanedTitle);
+    if (exact.length === 1) {
+      const r = await focusByHwnd(exact[0].hwnd);
+      return { ...r, matchedBy: 'title-exact', hwnd: exact[0].hwnd, windowTitle: exact[0].title };
+    }
+  }
+
+  // 2. Title substring match (some shells append " - <cwd>" etc)
+  if (cleanedTitle) {
+    const subs = cands.filter((w) => w.title.includes(cleanedTitle));
+    if (subs.length === 1) {
+      const r = await focusByHwnd(subs[0].hwnd);
+      return { ...r, matchedBy: 'title-substring', hwnd: subs[0].hwnd, windowTitle: subs[0].title };
+    }
+  }
+
+  // 3. Match by cwd basename (workspace name shows up in title for fresh launches)
+  if (cwdBase) {
+    const byCwd = cands.filter((w) => w.title.includes(cwdBase));
+    if (byCwd.length === 1) {
+      const r = await focusByHwnd(byCwd[0].hwnd);
+      return { ...r, matchedBy: 'cwd-basename', hwnd: byCwd[0].hwnd, windowTitle: byCwd[0].title };
+    }
+  }
+
+  // 4. Fall back to PID parent-chain walk (returns the wt process's
+  //    canonical MainWindowHandle — may be the wrong window when wt is
+  //    multi-window single-process, but better than nothing).
+  if (pid) {
+    const r = await focusByPid(pid);
+    return { ...r, matchedBy: 'pid-fallback', ambiguous: true };
+  }
+  return { ok: false, error: 'no match by title/cwd and no pid given', matchedBy: 'none' };
+}
+
 async function focusByHwnd(hwnd) {
   return await runPsHelper('focus-hwnd', hwnd);
 }
@@ -228,6 +285,7 @@ async function focusNewlyOpenedHwnd(beforeHwnds, processName, opts = {}) {
 
 module.exports = {
   focusByPid,
+  focusBySession,
   focusByHwnd,
   listWindowsOf,
   snapshotWindowsOf,

package/lib/sessions.js

@@ -110,8 +110,121 @@ async function listSessions() {
     .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
 }
 
+// Pull cwd/title/firstTimestamp from a jsonl by reading the head (cwd lives in
+// any user/assistant/attachment line) and tailing for the last ai-title.
+async function readJsonlMetadata(jsonlPath) {
+  let fd;
+  try {
+    fd = await fs.open(jsonlPath, 'r');
+    const stat = await fd.stat();
+    if (stat.size === 0) return { size: 0 };
+
+    const HEAD = Math.min(stat.size, 128 * 1024);
+    const headBuf = Buffer.alloc(HEAD);
+    await fd.read(headBuf, 0, HEAD, 0);
+    const headText = headBuf.toString('utf8');
+
+    let cwd = null;
+    let gitBranch = null;
+    let firstTimestamp = null;
+    for (const line of headText.split('\n')) {
+      if (!line) continue;
+      if (cwd && firstTimestamp) break;
+      if (!line.includes('"cwd"') && !line.includes('"timestamp"')) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.cwd && !cwd) cwd = obj.cwd;
+        if (obj.gitBranch && !gitBranch) gitBranch = obj.gitBranch;
+        if (obj.timestamp && !firstTimestamp) firstTimestamp = obj.timestamp;
+      } catch {}
+    }
+
+    const TAIL = Math.min(stat.size, 512 * 1024);
+    const tailBuf = Buffer.alloc(TAIL);
+    await fd.read(tailBuf, 0, TAIL, Math.max(0, stat.size - TAIL));
+    const tailText = tailBuf.toString('utf8');
+    let title = null;
+    const tailLines = tailText.split('\n');
+    for (let i = tailLines.length - 1; i >= 0; i--) {
+      if (!tailLines[i].includes('"type":"ai-title"')) continue;
+      try {
+        const obj = JSON.parse(tailLines[i]);
+        if (obj.aiTitle) { title = obj.aiTitle; break; }
+      } catch {}
+    }
+
+    return { cwd, gitBranch, firstTimestamp, title, size: stat.size };
+  } catch {
+    return {};
+  } finally {
+    if (fd) await fd.close().catch(() => {});
+  }
+}
+
+// List every recently-used Claude session by enumerating ~/.claude/projects/
+// *.jsonl files. Excludes session ids that are currently live (caller passes
+// `excludeIds` from listSessions()). Sorted by file mtime desc.
+async function listRecentSessions({ limit = 50, excludeIds = null } = {}) {
+  let projectDirs;
+  try {
+    projectDirs = await fs.readdir(PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+
+  const candidates = [];
+  for (const slugDir of projectDirs) {
+    const dirPath = path.join(PROJECTS_DIR, slugDir);
+    let entries;
+    try {
+      entries = await fs.readdir(dirPath);
+    } catch {
+      continue;
+    }
+    for (const file of entries) {
+      if (!file.endsWith('.jsonl')) continue;
+      const sessionId = file.slice(0, -'.jsonl'.length);
+      if (excludeIds && excludeIds.has(sessionId)) continue;
+      const fullPath = path.join(dirPath, file);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.size === 0) continue;
+        candidates.push({
+          sessionId,
+          slug: slugDir,
+          jsonlPath: fullPath,
+          mtime: stat.mtimeMs,
+        });
+      } catch {}
+    }
+  }
+
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  const top = candidates.slice(0, limit);
+
+  const results = await Promise.all(
+    top.map(async (c) => {
+      const meta = await readJsonlMetadata(c.jsonlPath);
+      const firstTs = meta.firstTimestamp ? Date.parse(meta.firstTimestamp) : null;
+      return {
+        sessionId: c.sessionId,
+        cwd: meta.cwd || null,
+        title: meta.title || null,
+        gitBranch: meta.gitBranch || null,
+        updatedAt: c.mtime,
+        startedAt: Number.isFinite(firstTs) ? firstTs : null,
+        jsonlPath: c.jsonlPath,
+      };
+    })
+  );
+
+  // Drop entries with no cwd — can't resume without one
+  return results.filter((r) => r.cwd);
+}
+
 module.exports = {
   listSessions,
+  listRecentSessions,
   projectSlugForCwd,
   getLiveClaudePids,
   SESSIONS_DIR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakapiano/ccsm",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Claude Code Session Manager — Windows web UI to manage many concurrent claude sessions: live list, snapshot/restore, focus existing window, new session in an isolated workspace with repo clones",
   "license": "MIT",
   "main": "server.js",

package/public/app.js

@@ -83,6 +83,29 @@ function renderSessions() {
     state.sessions.length ? `${state.sessions.length} live · last refresh ${new Date().toLocaleTimeString()}` : 'no live sessions';
 }
 
+function renderRecent() {
+  const tb = $('#recentTable tbody');
+  tb.innerHTML = '';
+  const recent = state.recent || [];
+  for (const s of recent) {
+    const tr = document.createElement('tr');
+    tr.innerHTML = `
+      <td><div class="ellipsis" title="${escapeHtml(s.title || '')}">${escapeHtml(s.title || '(no title)')}</div>
+          <div class="mono small" title="${escapeHtml(s.sessionId)}">${escapeHtml(s.sessionId.slice(0,8))}…</div></td>
+      <td><div class="ellipsis mono" title="${escapeHtml(s.cwd || '')}">${escapeHtml(s.cwd || '')}</div></td>
+      <td class="mono small">${escapeHtml(s.gitBranch || '')}</td>
+      <td title="${escapeHtml(fmtTime(s.updatedAt))}">${escapeHtml(fmtAgo(s.updatedAt))}</td>
+      <td title="${escapeHtml(fmtTime(s.startedAt))}">${escapeHtml(fmtAgo(s.startedAt))}</td>
+      <td style="text-align:right;">
+        <button class="btn small btn-primary" data-continue="${escapeHtml(s.sessionId)}" data-cwd="${escapeHtml(s.cwd)}" title="open a new wt window with claude --resume">continue</button>
+      </td>
+    `;
+    tb.appendChild(tr);
+  }
+  $('#recentMeta').textContent =
+    recent.length ? `${recent.length} recent · last refresh ${new Date().toLocaleTimeString()}` : 'no recent sessions';
+}
+
 // ---- snapshot render ----
 
 function renderSnapshot() {
@@ -165,7 +188,9 @@ function renderConfig() {
   $('#cfgClaudeCommand').value = state.config.claudeCommand || 'claude';
   $('#cfgCommandShell').value = state.config.commandShell || 'pwsh';
   $('#cfgAutoFocus').checked = state.config.autoFocusOnLaunch !== false;
-  $('#cfgAutoOpenBrowser').checked = state.config.autoOpenBrowser !== false;
+  $('#cfgBrowserMode').value =
+    state.config.browserMode ||
+    (state.config.autoOpenBrowser === false ? 'none' : 'app');
   const termSel = $('#cfgTerminal');
   termSel.innerHTML = (state.terminals || []).map((t) =>
     `<option value="${escapeHtml(t.name)}" ${t.name === state.config.terminal ? 'selected' : ''}>${escapeHtml(t.name)} (${escapeHtml(t.processName)})</option>`
@@ -205,7 +230,7 @@ function readConfigFromForm() {
     terminal: $('#cfgTerminal').value || 'wt',
     commandShell: $('#cfgCommandShell').value || 'pwsh',
     autoFocusOnLaunch: $('#cfgAutoFocus').checked,
-    autoOpenBrowser: $('#cfgAutoOpenBrowser').checked,
+    browserMode: $('#cfgBrowserMode').value || 'app',
     finderPrompt: $('#cfgFinderPrompt').value,
     repos,
   };
@@ -219,6 +244,12 @@ async function loadSessions() {
   renderSessions();
 }
 
+async function loadRecent() {
+  const r = await api('GET', '/api/sessions/recent?limit=50');
+  state.recent = r.recent;
+  renderRecent();
+}
+
 async function loadConfig() {
   const [cfg, terminals] = await Promise.all([
     api('GET', '/api/config'),
@@ -247,7 +278,7 @@ async function loadWorkspaces() {
 }
 
 async function refreshAll() {
-  await Promise.all([loadSessions(), loadSnapshot(), loadWorkspaces()]);
+  await Promise.all([loadSessions(), loadRecent(), loadSnapshot(), loadWorkspaces()]);
 }
 
 // ---- event wiring ----
@@ -296,6 +327,24 @@ function wireUp() {
     }
   });
 
+  $('#recentTable').addEventListener('click', async (ev) => {
+    const btn = ev.target.closest('button[data-continue]');
+    if (!btn) return;
+    const sessionId = btn.dataset.continue;
+    const cwd = btn.dataset.cwd;
+    btn.disabled = true;
+    try {
+      await api('POST', `/api/sessions/${sessionId}/resume`, { cwd });
+      toast(`continuing ${sessionId.slice(0, 8)}…`);
+      setTimeout(() => loadSessions().catch(() => {}), 3000);
+      setTimeout(() => loadRecent().catch(() => {}), 4000);
+    } catch (e) {
+      toast(e.message, 'error');
+    } finally {
+      btn.disabled = false;
+    }
+  });
+
   $('#finderBtn').onclick = async () => {
     try {
       await api('POST', '/api/sessions/finder');
@@ -406,6 +455,7 @@ function startAutoRefresh() {
   stopAutoRefresh();
   state.autoTimer = setInterval(() => {
     loadSessions().catch(() => {});
+    loadRecent().catch(() => {});
     loadSnapshot().catch(() => {});
   }, 5000);
 }

package/public/index.html

@@ -49,6 +49,28 @@
         </div>
       </section>
 
+      <section class="panel">
+        <header class="panel-header">
+          <h2>recently closed</h2>
+          <span id="recentMeta" class="muted"></span>
+        </header>
+        <div class="table-wrap">
+          <table id="recentTable" class="data-table">
+            <thead>
+              <tr>
+                <th>title</th>
+                <th>cwd</th>
+                <th>branch</th>
+                <th>updated</th>
+                <th>started</th>
+                <th></th>
+              </tr>
+            </thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </section>
+
       <section class="panel">
         <header class="panel-header">
           <h2>snapshot</h2>
@@ -123,9 +145,12 @@
             <input id="cfgAutoFocus" type="checkbox" />
             <span style="color: var(--text);">auto-focus newly launched window</span>
           </label>
-          <label class="full" style="flex-direction: row; align-items: center; gap: 8px;">
-            <input id="cfgAutoOpenBrowser" type="checkbox" />
-            <span style="color: var(--text);">auto-open this UI in browser on server start</span>
+          <label>browser open mode (on server start)
+            <select id="cfgBrowserMode" class="select">
+              <option value="app">app — Edge/Chrome chromeless window</option>
+              <option value="tab">tab — default browser, normal tab</option>
+              <option value="none">off — don't open anything</option>
+            </select>
           </label>
           <label class="full">finder prompt
             <textarea id="cfgFinderPrompt" rows="3"></textarea>

package/server.js

@@ -4,7 +4,7 @@
 const path = require('node:path');
 const express = require('express');
 
-const { listSessions } = require('./lib/sessions');
+const { listSessions, listRecentSessions } = require('./lib/sessions');
 const { loadConfig, saveConfig, DATA_DIR } = require('./lib/config');
 const {
   saveSnapshot,
@@ -26,6 +26,7 @@ const {
 } = require('./lib/launcher');
 const {
   focusByPid,
+  focusBySession,
   snapshotWindowsOf,
   focusNewlyOpenedHwnd,
 } = require('./lib/focus');
@@ -61,6 +62,14 @@ app.get('/api/sessions', asyncH(async (_req, res) => {
   res.json({ sessions, takenAt: Date.now() });
 }));
 
+app.get('/api/sessions/recent', asyncH(async (req, res) => {
+  const limit = Math.min(200, Number(req.query.limit) || 50);
+  const live = await listSessions();
+  const excludeIds = new Set(live.map((s) => s.sessionId));
+  const recent = await listRecentSessions({ limit, excludeIds });
+  res.json({ recent, takenAt: Date.now() });
+}));
+
 // ---- config ----
 
 app.get('/api/config', asyncH(async (_req, res) => {
@@ -296,8 +305,13 @@ app.post('/api/sessions/:sessionId/focus', asyncH(async (req, res) => {
   const sessions = await listSessions();
   const s = sessions.find((x) => x.sessionId === sessionId);
   if (!s) return res.status(404).json({ error: `session ${sessionId} not live` });
-  const result = await focusByPid(s.pid);
-  res.json({ session: { pid: s.pid, sessionId: s.sessionId, cwd: s.cwd }, ...result });
+  const result = await focusBySession({
+    pid: s.pid,
+    sessionId: s.sessionId,
+    title: s.title,
+    cwd: s.cwd,
+  });
+  res.json({ session: { pid: s.pid, sessionId: s.sessionId, cwd: s.cwd, title: s.title }, ...result });
 }));
 
 // ---- terminal kinds ----
@@ -342,12 +356,53 @@ function listenWithFallback(preferred) {
   });
 }
 
-function openInBrowser(url) {
-  if (process.platform !== 'win32') return;
+function findAppModeBrowser() {
+  const candidates = [
+    'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+    'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+    'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+    process.env.LOCALAPPDATA &&
+      path.join(process.env.LOCALAPPDATA, 'Google\\Chrome\\Application\\chrome.exe'),
+    'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+  ].filter(Boolean);
+  const fs = require('node:fs');
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function openInBrowser(url, mode) {
+  if (process.platform !== 'win32' || mode === 'none') return;
   const { spawn } = require('node:child_process');
-  // cmd's `start` builtin opens URL in the default browser. The empty "" is
-  // the window-title slot for `start`, otherwise `<url>` would be eaten as
-  // the title when it has spaces.
+  const fs = require('node:fs');
+
+  if (mode === 'app') {
+    const exe = findAppModeBrowser();
+    if (exe) {
+      // Per-ccsm profile dir so we don't get the "already running, --app
+      // ignored" merge behavior of Edge/Chrome when the user has a normal
+      // window open. Lives under DATA_DIR so it's tidied with the rest.
+      const profileDir = path.join(DATA_DIR, 'browser-profile');
+      fs.mkdirSync(profileDir, { recursive: true });
+      const child = spawn(
+        exe,
+        [
+          `--app=${url}`,
+          `--user-data-dir=${profileDir}`,
+          '--window-size=1400,1000',
+          '--no-first-run',
+          '--no-default-browser-check',
+        ],
+        { detached: true, stdio: 'ignore' }
+      );
+      child.unref();
+      return;
+    }
+    console.log('[ccsm] no Edge/Chrome found for app mode, falling back to default browser');
+  }
+
+  // mode === 'tab' (or app-mode fallback)
   const child = spawn('cmd.exe', ['/c', 'start', '', url], {
     detached: true,
     stdio: 'ignore',
@@ -364,7 +419,8 @@ function openInBrowser(url) {
   console.log(`data dir:        ${DATA_DIR}`);
   console.log(`work dir:        ${cfg.workDir}`);
   console.log(`terminal:        ${cfg.terminal} · ${cfg.claudeCommand}${cfg.terminal === 'wt' ? ` (via ${cfg.commandShell})` : ''}`);
-  if (cfg.autoOpenBrowser !== false) openInBrowser(url);
+  const mode = cfg.browserMode || (cfg.autoOpenBrowser === false ? 'none' : 'app');
+  openInBrowser(url, mode);
   startSnapshotLoop();
 })().catch((err) => {
   console.error('startup failed:', err);