claude-remote-cli 2.0.0 → 2.2.0

package/README.md

@@ -142,8 +142,10 @@ The PIN hash is stored in config under `pinHash`. To reset:
 ## Features
 
 - **PIN-protected access** with rate limiting
-- **Branch-aware sessions** — create worktrees from new or existing branches with a type-to-search branch picker
-- **Worktree isolation** — each session runs in its own git worktree under `.worktrees/`
+- **Repo sessions** — open Claude directly in any repo root, with fresh or `--continue` mode (one session per repo)
+- **Branch-aware worktrees** — create worktrees from new or existing branches with a type-to-search branch picker
+- **Tabbed sidebar** — switch between Repos and Worktrees views with shared filters and item counts
+- **Worktree isolation** — each worktree session runs in its own git worktree under `.worktrees/`
 - **Resume sessions** — click inactive worktrees to reconnect with `--continue`
 - **Persistent session names** — display names, branch names, and timestamps survive server restarts
 - **Clipboard image paste** — paste screenshots directly into remote terminal sessions (macOS clipboard + xclip on Linux)

package/dist/bin/claude-remote-cli.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import fs from 'node:fs';
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import * as service from '../server/service.js';
 import { DEFAULTS } from '../server/config.js';
 const execFileAsync = promisify(execFile);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trimEnd();
+}
 // Parse CLI flags
 const args = process.argv.slice(2);
 if (args.includes('--help') || args.includes('-h')) {
@@ -19,12 +23,17 @@ Commands:
   install            Install as a background service (survives reboot)
   uninstall          Stop and remove the background service
   status             Show whether the service is running
+  worktree           Manage git worktrees (wraps git worktree)
+    add [path] [-b branch] [--yolo]   Create worktree and launch Claude
+    remove <path>                      Forward to git worktree remove
+    list                               Forward to git worktree list
 
 Options:
   --bg               Shortcut: install and start as background service
   --port <port>      Override server port (default: 3456)
   --host <host>      Override bind address (default: 0.0.0.0)
   --config <path>    Path to config.json (default: ~/.config/claude-remote-cli/config.json)
+  --yolo             With 'worktree add': pass --dangerously-skip-permissions to Claude
   --version, -v      Show version
   --help, -h         Show this help`);
     process.exit(0);
@@ -87,6 +96,76 @@ if (command === 'update') {
     }
     process.exit(0);
 }
+if (command === 'worktree') {
+    const wtArgs = args.slice(1);
+    const subCommand = wtArgs[0];
+    if (!subCommand) {
+        console.error('Usage: claude-remote-cli worktree <add|remove|list> [options]');
+        process.exit(1);
+    }
+    if (subCommand !== 'add') {
+        try {
+            const result = await execFileAsync('git', ['worktree', ...wtArgs]);
+            if (result.stdout)
+                console.log(result.stdout.trimEnd());
+        }
+        catch (err) {
+            console.error(execErrorMessage(err, 'git worktree failed'));
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Handle 'add' -- strip --yolo, determine path, forward to git, then launch claude
+    const hasYolo = wtArgs.includes('--yolo');
+    const gitWtArgs = wtArgs.filter(function (a) { return a !== '--yolo'; });
+    const addSubArgs = gitWtArgs.slice(1);
+    let targetDir;
+    const bIdx = gitWtArgs.indexOf('-b');
+    const branchForDefault = bIdx !== -1 && bIdx + 1 < gitWtArgs.length ? gitWtArgs[bIdx + 1] : undefined;
+    if (addSubArgs.length === 0 || addSubArgs[0].startsWith('-')) {
+        let repoRoot;
+        try {
+            const result = await execFileAsync('git', ['rev-parse', '--show-toplevel']);
+            repoRoot = result.stdout.trim();
+        }
+        catch {
+            console.error('Not inside a git repository.');
+            process.exit(1);
+        }
+        const dirName = branchForDefault
+            ? branchForDefault.replace(/\//g, '-')
+            : 'worktree-' + Date.now().toString(36);
+        targetDir = path.join(repoRoot, '.worktrees', dirName);
+        gitWtArgs.splice(1, 0, targetDir);
+    }
+    else {
+        targetDir = path.resolve(addSubArgs[0]);
+    }
+    try {
+        const result = await execFileAsync('git', ['worktree', ...gitWtArgs]);
+        if (result.stdout)
+            console.log(result.stdout.trimEnd());
+    }
+    catch (err) {
+        console.error(execErrorMessage(err, 'git worktree add failed'));
+        process.exit(1);
+    }
+    console.log(`Worktree created at ${targetDir}`);
+    const claudeArgs = [];
+    if (hasYolo)
+        claudeArgs.push('--dangerously-skip-permissions');
+    console.log(`Launching claude${hasYolo ? ' (yolo mode)' : ''} in ${targetDir}...`);
+    const child = spawn('claude', claudeArgs, {
+        cwd: targetDir,
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDECODE: undefined },
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    // Block until child exits via the handler above
+    await new Promise(() => { });
+}
 if (command === 'install' || command === 'uninstall' || command === 'status' || args.includes('--bg')) {
     if (command === 'uninstall') {
         runServiceCommand(() => { service.uninstall(); });

package/dist/server/index.js

@@ -12,7 +12,7 @@ import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, ensureMetaDir }
 import * as auth from './auth.js';
 import * as sessions from './sessions.js';
 import { setupWebSocket } from './ws.js';
-import { WorktreeWatcher } from './watcher.js';
+import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -59,6 +59,10 @@ async function getLatestVersion() {
         return null;
     }
 }
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trim();
+}
 function parseTTL(ttl) {
     if (typeof ttl !== 'string')
         return 24 * 60 * 60 * 1000;
@@ -246,28 +250,30 @@ async function main() {
             reposToScan = scanAllRepos(roots);
         }
         for (const repo of reposToScan) {
-            const worktreeDir = path.join(repo.path, '.worktrees');
-            let entries;
-            try {
-                entries = fs.readdirSync(worktreeDir, { withFileTypes: true });
-            }
-            catch (_) {
-                continue;
-            }
-            for (const entry of entries) {
-                if (!entry.isDirectory())
+            for (const dir of WORKTREE_DIRS) {
+                const worktreeDir = path.join(repo.path, dir);
+                let entries;
+                try {
+                    entries = fs.readdirSync(worktreeDir, { withFileTypes: true });
+                }
+                catch (_) {
                     continue;
-                const wtPath = path.join(worktreeDir, entry.name);
-                const meta = readMeta(CONFIG_PATH, wtPath);
-                worktrees.push({
-                    name: entry.name,
-                    path: wtPath,
-                    repoName: repo.name,
-                    repoPath: repo.path,
-                    root: repo.root,
-                    displayName: meta ? meta.displayName : '',
-                    lastActivity: meta ? meta.lastActivity : '',
-                });
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const wtPath = path.join(worktreeDir, entry.name);
+                    const meta = readMeta(CONFIG_PATH, wtPath);
+                    worktrees.push({
+                        name: entry.name,
+                        path: wtPath,
+                        repoName: repo.name,
+                        repoPath: repo.path,
+                        root: repo.root,
+                        displayName: meta ? meta.displayName : '',
+                        lastActivity: meta ? meta.lastActivity : '',
+                    });
+                }
             }
         }
         res.json(worktrees);
@@ -315,9 +321,8 @@ async function main() {
             res.status(400).json({ error: 'worktreePath and repoPath are required' });
             return;
         }
-        // Validate the path is inside a .worktrees/ directory
-        if (!worktreePath.includes(path.sep + '.worktrees' + path.sep)) {
-            res.status(400).json({ error: 'Path is not inside a .worktrees/ directory' });
+        if (!isValidWorktreePath(worktreePath)) {
+            res.status(400).json({ error: 'Path is not inside a worktree directory' });
             return;
         }
         // Check no active session is using this worktree
@@ -335,9 +340,7 @@ async function main() {
             await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: repoPath });
         }
         catch (err) {
-            const execErr = err;
-            const message = (execErr.stderr || execErr.message || 'Failed to remove worktree').trim();
-            res.status(500).json({ error: message });
+            res.status(500).json({ error: execErrorMessage(err, 'Failed to remove worktree') });
             return;
         }
         try {
@@ -427,9 +430,7 @@ async function main() {
                 }
             }
             catch (err) {
-                const execErr = err;
-                const message = (execErr.stderr || execErr.message || 'Failed to create worktree').trim();
-                res.status(500).json({ error: message });
+                res.status(500).json({ error: execErrorMessage(err, 'Failed to create worktree') });
                 return;
             }
             worktreeName = dirName;
@@ -439,6 +440,7 @@ async function main() {
         }
         const displayName = branchName || worktreeName;
         const session = sessions.create({
+            type: 'worktree',
             repoName: name,
             repoPath: sessionRepoPath,
             cwd,
@@ -459,6 +461,36 @@ async function main() {
         }
         res.status(201).json(session);
     });
+    // POST /sessions/repo — start a session in the repo root (no worktree)
+    app.post('/sessions/repo', requireAuth, (req, res) => {
+        const { repoPath, repoName, continue: continueSession, claudeArgs } = req.body;
+        if (!repoPath) {
+            res.status(400).json({ error: 'repoPath is required' });
+            return;
+        }
+        // One repo session at a time
+        const existing = sessions.findRepoSession(repoPath);
+        if (existing) {
+            res.status(409).json({ error: 'A session already exists for this repo', sessionId: existing.id });
+            return;
+        }
+        const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
+        const baseArgs = [...(config.claudeArgs || []), ...(claudeArgs || [])];
+        const args = continueSession ? ['--continue', ...baseArgs] : [...baseArgs];
+        const roots = config.rootDirs || [];
+        const root = roots.find(function (r) { return repoPath.startsWith(r); }) || '';
+        const session = sessions.create({
+            type: 'repo',
+            repoName: name,
+            repoPath,
+            cwd: repoPath,
+            root,
+            displayName: name,
+            command: config.claudeCommand,
+            args,
+        });
+        res.status(201).json(session);
+    });
     // DELETE /sessions/:id
     app.delete('/sessions/:id', requireAuth, (req, res) => {
         try {

package/dist/server/sessions.js

@@ -11,7 +11,7 @@ let idleChangeCallback = null;
 function onIdleChange(cb) {
     idleChangeCallback = cb;
 }
-function create({ repoName, repoPath, cwd, root, worktreeName, displayName, command, args = [], cols = 80, rows = 24, configPath }) {
+function create({ type, repoName, repoPath, cwd, root, worktreeName, displayName, command, args = [], cols = 80, rows = 24, configPath }) {
     const id = crypto.randomBytes(8).toString('hex');
     const createdAt = new Date().toISOString();
     // Strip CLAUDECODE env var to allow spawning claude inside a claude-managed server
@@ -30,6 +30,7 @@ function create({ repoName, repoPath, cwd, root, worktreeName, displayName, comm
     const MAX_SCROLLBACK = 256 * 1024; // 256KB max
     const session = {
         id,
+        type: type || 'worktree',
         root: root || '',
         repoName: repoName || '',
         repoPath,
@@ -96,15 +97,16 @@ function create({ repoName, repoPath, cwd, root, worktreeName, displayName, comm
         const tmpDir = path.join(os.tmpdir(), 'claude-remote-cli', id);
         fs.rm(tmpDir, { recursive: true, force: true }, () => { });
     });
-    return { id, root: session.root, repoName: session.repoName, repoPath, worktreeName: session.worktreeName, displayName: session.displayName, pid: ptyProcess.pid, createdAt, lastActivity: createdAt, idle: false };
+    return { id, type: session.type, root: session.root, repoName: session.repoName, repoPath, worktreeName: session.worktreeName, displayName: session.displayName, pid: ptyProcess.pid, createdAt, lastActivity: createdAt, idle: false };
 }
 function get(id) {
     return sessions.get(id);
 }
 function list() {
     return Array.from(sessions.values())
-        .map(({ id, root, repoName, repoPath, worktreeName, displayName, createdAt, lastActivity, idle }) => ({
+        .map(({ id, type, root, repoName, repoPath, worktreeName, displayName, createdAt, lastActivity, idle }) => ({
         id,
+        type,
         root,
         repoName,
         repoPath,
@@ -145,4 +147,7 @@ function write(id, data) {
     }
     session.pty.write(data);
 }
-export { create, get, list, kill, resize, updateDisplayName, write, onIdleChange };
+function findRepoSession(repoPath) {
+    return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
+}
+export { create, get, list, kill, resize, updateDisplayName, write, onIdleChange, findRepoSession };

package/dist/server/watcher.js

@@ -1,6 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { EventEmitter } from 'node:events';
+export const WORKTREE_DIRS = ['.worktrees', '.claude/worktrees'];
+export function isValidWorktreePath(worktreePath) {
+    const resolved = path.resolve(worktreePath);
+    return WORKTREE_DIRS.some(function (dir) {
+        return resolved.includes(path.sep + dir + path.sep);
+    });
+}
 export class WorktreeWatcher extends EventEmitter {
     _watchers;
     _debounceTimer;
@@ -30,12 +37,16 @@ export class WorktreeWatcher extends EventEmitter {
         }
     }
     _watchRepo(repoPath) {
-        const worktreeDir = path.join(repoPath, '.worktrees');
-        if (fs.existsSync(worktreeDir)) {
-            this._addWatch(worktreeDir);
+        let anyWatched = false;
+        for (const dir of WORKTREE_DIRS) {
+            const worktreeDir = path.join(repoPath, dir);
+            if (fs.existsSync(worktreeDir)) {
+                this._addWatch(worktreeDir);
+                anyWatched = true;
+            }
         }
-        else {
-            // Watch the repo root so we detect when .worktrees/ is first created
+        if (!anyWatched) {
+            // Watch repo root so we detect when either dir is first created
             this._addWatch(repoPath);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",

package/public/app.js

@@ -39,6 +39,8 @@
   var dialogYolo = document.getElementById('dialog-yolo');
   var dialogBranchInput = document.getElementById('dialog-branch-input');
   var dialogBranchList = document.getElementById('dialog-branch-list');
+  var dialogContinue = document.getElementById('dialog-continue');
+  var dialogContinueField = document.getElementById('dialog-continue-field');
   var contextMenu = document.getElementById('context-menu');
   var ctxResumeYolo = document.getElementById('ctx-resume-yolo');
   var ctxDeleteWorktree = document.getElementById('ctx-delete-worktree');
@@ -60,6 +62,10 @@
   var terminalScrollbarThumb = document.getElementById('terminal-scrollbar-thumb');
   var mobileInput = document.getElementById('mobile-input');
   var mobileHeader = document.getElementById('mobile-header');
+  var sidebarTabs = document.querySelectorAll('.sidebar-tab');
+  var tabReposCount = document.getElementById('tab-repos-count');
+  var tabWorktreesCount = document.getElementById('tab-worktrees-count');
+  var activeTab = 'repos';
   var isMobileDevice = 'ontouchstart' in window;
 
   // Context menu state
@@ -92,6 +98,7 @@
   var cachedWorktrees = [];
   var allRepos = [];
   var allBranches = [];
+  var cachedRepos = [];
   var attentionSessions = {};
 
   function loadBranches(repoPath) {
@@ -523,10 +530,12 @@
     Promise.all([
       fetch('/sessions').then(function (res) { return res.json(); }),
       fetch('/worktrees').then(function (res) { return res.json(); }),
+      fetch('/repos').then(function (res) { return res.json(); }),
     ])
       .then(function (results) {
         cachedSessions = results[0] || [];
         cachedWorktrees = results[1] || [];
+        cachedRepos = results[2] || [];
 
         // Prune attention flags for sessions that no longer exist
         var activeIds = {};
@@ -606,6 +615,16 @@
     renderUnifiedList();
   });
 
+  sidebarTabs.forEach(function (tab) {
+    tab.addEventListener('click', function () {
+      activeTab = tab.dataset.tab;
+      sidebarTabs.forEach(function (t) { t.classList.remove('active'); });
+      tab.classList.add('active');
+      newSessionBtn.textContent = activeTab === 'repos' ? '+ New Session' : '+ New Worktree';
+      renderUnifiedList();
+    });
+  });
+
   function rootShortName(path) {
     return path.split('/').filter(Boolean).pop() || path;
   }
@@ -633,7 +652,42 @@
     var repoFilter = sidebarRepoFilter.value;
     var textFilter = sessionFilter.value.toLowerCase();
 
-    var filteredSessions = cachedSessions.filter(function (s) {
+    // Split sessions by type
+    var repoSessions = cachedSessions.filter(function (s) { return s.type === 'repo'; });
+    var worktreeSessions = cachedSessions.filter(function (s) { return s.type !== 'repo'; });
+
+    // Filtered repo sessions
+    var filteredRepoSessions = repoSessions.filter(function (s) {
+      if (rootFilter && s.root !== rootFilter) return false;
+      if (repoFilter && s.repoName !== repoFilter) return false;
+      if (textFilter) {
+        var name = (s.displayName || s.repoName || s.id).toLowerCase();
+        if (name.indexOf(textFilter) === -1) return false;
+      }
+      return true;
+    });
+
+    // Idle repos: all repos without an active repo session
+    var activeRepoPathSet = new Set();
+    repoSessions.forEach(function (s) { activeRepoPathSet.add(s.repoPath); });
+
+    var filteredIdleRepos = cachedRepos.filter(function (r) {
+      if (activeRepoPathSet.has(r.path)) return false;
+      if (rootFilter && r.root !== rootFilter) return false;
+      if (repoFilter && r.name !== repoFilter) return false;
+      if (textFilter) {
+        var name = (r.name || '').toLowerCase();
+        if (name.indexOf(textFilter) === -1) return false;
+      }
+      return true;
+    });
+
+    filteredIdleRepos.sort(function (a, b) {
+      return (a.name || '').localeCompare(b.name || '');
+    });
+
+    // Filtered worktree sessions
+    var filteredWorktreeSessions = worktreeSessions.filter(function (s) {
       if (rootFilter && s.root !== rootFilter) return false;
       if (repoFilter && s.repoName !== repoFilter) return false;
       if (textFilter) {
@@ -643,8 +697,9 @@
       return true;
     });
 
+    // Inactive worktrees (deduped against active sessions)
     var activeWorktreePaths = new Set();
-    cachedSessions.forEach(function (s) {
+    worktreeSessions.forEach(function (s) {
       if (s.repoPath) activeWorktreePaths.add(s.repoPath);
     });
 
@@ -663,23 +718,35 @@
       return (a.name || '').localeCompare(b.name || '');
     });
 
-    sessionList.innerHTML = '';
+    // Update tab counts
+    tabReposCount.textContent = filteredRepoSessions.length + filteredIdleRepos.length;
+    tabWorktreesCount.textContent = filteredWorktreeSessions.length + filteredWorktrees.length;
 
-    filteredSessions.forEach(function (session) {
-      sessionList.appendChild(createActiveSessionLi(session));
-    });
+    // Render based on active tab
+    sessionList.innerHTML = '';
 
-    if (filteredSessions.length > 0 && filteredWorktrees.length > 0) {
-      var divider = document.createElement('li');
-      divider.className = 'session-divider';
-      divider.textContent = 'Available';
-      sessionList.appendChild(divider);
+    if (activeTab === 'repos') {
+      filteredRepoSessions.forEach(function (session) {
+        sessionList.appendChild(createActiveSessionLi(session));
+      });
+      if (filteredRepoSessions.length > 0 && filteredIdleRepos.length > 0) {
+        sessionList.appendChild(createSectionDivider('Available'));
+      }
+      filteredIdleRepos.forEach(function (repo) {
+        sessionList.appendChild(createIdleRepoLi(repo));
+      });
+    } else {
+      filteredWorktreeSessions.forEach(function (session) {
+        sessionList.appendChild(createActiveSessionLi(session));
+      });
+      if (filteredWorktreeSessions.length > 0 && filteredWorktrees.length > 0) {
+        sessionList.appendChild(createSectionDivider('Available'));
+      }
+      filteredWorktrees.forEach(function (wt) {
+        sessionList.appendChild(createInactiveWorktreeLi(wt));
+      });
     }
 
-    filteredWorktrees.forEach(function (wt) {
-      sessionList.appendChild(createInactiveWorktreeLi(wt));
-    });
-
     highlightActiveSession();
   }
 
@@ -824,6 +891,45 @@
     return li;
   }
 
+  function createSectionDivider(label) {
+    var divider = document.createElement('li');
+    divider.className = 'session-divider';
+    divider.textContent = label;
+    return divider;
+  }
+
+  function createIdleRepoLi(repo) {
+    var li = document.createElement('li');
+    li.className = 'inactive-worktree';
+    li.title = repo.path;
+
+    var infoDiv = document.createElement('div');
+    infoDiv.className = 'session-info';
+
+    var nameSpan = document.createElement('span');
+    nameSpan.className = 'session-name';
+    nameSpan.textContent = repo.name;
+    nameSpan.title = repo.name;
+
+    var dot = document.createElement('span');
+    dot.className = 'status-dot status-dot--inactive';
+
+    var subSpan = document.createElement('span');
+    subSpan.className = 'session-sub';
+    subSpan.textContent = repo.root ? rootShortName(repo.root) : repo.path;
+
+    infoDiv.appendChild(dot);
+    infoDiv.appendChild(nameSpan);
+    infoDiv.appendChild(subSpan);
+    li.appendChild(infoDiv);
+
+    li.addEventListener('click', function () {
+      openNewSessionDialogForRepo(repo);
+    });
+
+    return li;
+  }
+
   function startRename(li, session) {
     var nameSpan = li.querySelector('.session-name');
     if (!nameSpan) return;
@@ -1043,13 +1149,74 @@
       .catch(function () {});
   }
 
-  newSessionBtn.addEventListener('click', function () {
+  function resetDialogFields() {
     customPath.value = '';
     dialogYolo.checked = false;
+    dialogContinue.checked = false;
     dialogBranchInput.value = '';
     dialogBranchList.hidden = true;
     allBranches = [];
     populateDialogRootSelect();
+  }
+
+  function showDialogForTab(tab) {
+    var dialogBranchField = dialogBranchInput.closest('.dialog-field');
+    if (tab === 'repos') {
+      dialogBranchField.hidden = true;
+      dialogContinueField.hidden = false;
+      dialogStart.textContent = 'New Session';
+    } else {
+      dialogBranchField.hidden = false;
+      dialogContinueField.hidden = true;
+      dialogStart.textContent = 'New Worktree';
+    }
+  }
+
+  function openNewSessionDialogForRepo(repo) {
+    resetDialogFields();
+
+    if (repo.root) {
+      dialogRootSelect.value = repo.root;
+      dialogRootSelect.dispatchEvent(new Event('change'));
+      dialogRepoSelect.value = repo.path;
+    }
+
+    showDialogForTab('repos');
+    dialog.showModal();
+  }
+
+  function startRepoSession(repoPath, continueSession, claudeArgs) {
+    var body = { repoPath: repoPath };
+    if (continueSession) body.continue = true;
+    if (claudeArgs) body.claudeArgs = claudeArgs;
+
+    fetch('/sessions/repo', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+      .then(function (res) {
+        if (res.status === 409) {
+          return res.json().then(function (data) {
+            if (dialog.open) dialog.close();
+            refreshAll();
+            if (data.sessionId) connectToSession(data.sessionId);
+            return null;
+          });
+        }
+        return res.json();
+      })
+      .then(function (data) {
+        if (!data) return;
+        if (dialog.open) dialog.close();
+        refreshAll();
+        if (data.id) connectToSession(data.id);
+      })
+      .catch(function () {});
+  }
+
+  newSessionBtn.addEventListener('click', function () {
+    resetDialogFields();
 
     var sidebarRoot = sidebarRootFilter.value;
     if (sidebarRoot) {
@@ -1069,6 +1236,7 @@
       dialogRepoSelect.disabled = true;
     }
 
+    showDialogForTab(activeTab);
     dialog.showModal();
   });
 
@@ -1076,8 +1244,13 @@
     var repoPathValue = customPath.value.trim() || dialogRepoSelect.value;
     if (!repoPathValue) return;
     var args = dialogYolo.checked ? ['--dangerously-skip-permissions'] : undefined;
-    var branch = dialogBranchInput.value.trim() || undefined;
-    startSession(repoPathValue, undefined, args, branch);
+
+    if (activeTab === 'repos') {
+      startRepoSession(repoPathValue, dialogContinue.checked, args);
+    } else {
+      var branch = dialogBranchInput.value.trim() || undefined;
+      startSession(repoPathValue, undefined, args, branch);
+    }
   });
 
   customPath.addEventListener('blur', function () {

package/public/index.html

@@ -52,6 +52,10 @@
         </select>
         <input type="text" id="session-filter" placeholder="Filter..." />
       </div>
+      <div class="sidebar-tabs">
+        <button class="sidebar-tab active" data-tab="repos">Repos (<span id="tab-repos-count">0</span>)</button>
+        <button class="sidebar-tab" data-tab="worktrees">Worktrees (<span id="tab-worktrees-count">0</span>)</button>
+      </div>
       <ul id="session-list"></ul>
       <button id="new-session-btn">+ New Session</button>
       <button id="settings-btn">Settings</button>
@@ -140,6 +144,14 @@
       <span class="dialog-option-hint">Leave empty for auto-generated name</span>
     </div>
 
+    <div class="dialog-field" id="dialog-continue-field" hidden>
+      <label>
+        <input type="checkbox" id="dialog-continue" />
+        Continue previous conversation
+      </label>
+      <span class="dialog-option-hint">Resume where you left off (--continue)</span>
+    </div>
+
     <hr class="dialog-separator" />
     <div class="dialog-custom-path">
       <label for="custom-path-input">Or enter a local path:</label>

package/public/style.css

@@ -202,6 +202,36 @@ html, body {
   border-color: var(--accent);
 }
 
+/* Sidebar Tabs */
+.sidebar-tabs {
+  display: flex;
+  gap: 0;
+  padding: 0 8px;
+  border-bottom: 1px solid var(--border);
+}
+
+.sidebar-tab {
+  flex: 1;
+  background: none;
+  border: none;
+  border-bottom: 2px solid transparent;
+  color: var(--text-muted);
+  font-size: 0.7rem;
+  padding: 6px 4px;
+  cursor: pointer;
+  transition: color 0.15s, border-color 0.15s;
+  text-align: center;
+}
+
+.sidebar-tab:hover {
+  color: var(--text);
+}
+
+.sidebar-tab.active {
+  color: var(--accent);
+  border-bottom-color: var(--accent);
+}
+
 #session-list {
   list-style: none;
   flex: 1;