droid-patch 0.7.0 → 0.8.0

package/dist/cli.mjs

@@ -531,6 +531,45 @@ PROXY_PID=""
 PORT_FILE="/tmp/droid-websearch-\$\$.port"
 STANDALONE="${standalone ? "1" : "0"}"
 
+# Passthrough for non-interactive/meta commands (avoid starting a proxy for help/version/etc)
+should_passthrough() {
+  # Any help/version flags before "--"
+  for arg in "\$@"; do
+    if [ "\$arg" = "--" ]; then
+      break
+    fi
+    case "\$arg" in
+      --help|-h|--version|-V)
+        return 0
+        ;;
+    esac
+  done
+
+  # Top-level command token
+  local end_opts=0
+  for arg in "\$@"; do
+    if [ "\$arg" = "--" ]; then
+      end_opts=1
+      continue
+    fi
+    if [ "\$end_opts" -eq 0 ] && [[ "\$arg" == -* ]]; then
+      continue
+    fi
+    case "\$arg" in
+      help|version|completion|completions|exec)
+        return 0
+        ;;
+    esac
+    break
+  done
+
+  return 1
+}
+
+if should_passthrough "\$@"; then
+  exec "\$DROID_BIN" "\$@"
+fi
+
 # Cleanup function - kill proxy when droid exits
 cleanup() {
   if [ -n "\$PROXY_PID" ] && kill -0 "\$PROXY_PID" 2>/dev/null; then
@@ -660,6 +699,33 @@ function isPositiveInt(n) {
   return Number.isFinite(n) && n > 0;
 }
 
+function firstNonNull(promises) {
+  const list = Array.isArray(promises) ? promises : [];
+  if (list.length === 0) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    let pending = list.length;
+    let done = false;
+    for (const p of list) {
+      Promise.resolve(p)
+        .then((value) => {
+          if (done) return;
+          if (value) {
+            done = true;
+            resolve(value);
+            return;
+          }
+          pending -= 1;
+          if (pending <= 0) resolve(null);
+        })
+        .catch(() => {
+          if (done) return;
+          pending -= 1;
+          if (pending <= 0) resolve(null);
+        });
+    }
+  });
+}
+
 function listPidsInProcessGroup(pgid) {
   if (!isPositiveInt(pgid)) return [];
   try {
@@ -712,10 +778,11 @@ function resolveOpenSessionFromPids(pids) {
   return null;
 }
 
-async function resolveSessionFromProcessGroup() {
+async function resolveSessionFromProcessGroup(shouldAbort, maxTries = 20) {
   if (!isPositiveInt(PGID)) return null;
   // Wait a little for droid to create/open the session files.
-  for (let i = 0; i < 80; i++) {
+  for (let i = 0; i < maxTries; i++) {
+    if (shouldAbort && shouldAbort()) return null;
     const pids = listPidsInProcessGroup(PGID);
     const found = resolveOpenSessionFromPids(pids);
     if (found) return found;
@@ -872,8 +939,9 @@ function pickLatestSessionAcross(workspaceDirs) {
   return best ? { workspaceDir: best.workspaceDir, id: best.id } : null;
 }
 
-async function waitForNewSessionAcross(workspaceDirs, knownIdsByWorkspace, startMs) {
+async function waitForNewSessionAcross(workspaceDirs, knownIdsByWorkspace, startMs, shouldAbort) {
   for (let i = 0; i < 80; i++) {
+    if (shouldAbort && shouldAbort()) return null;
     let best = null;
     for (const dir of workspaceDirs) {
       const known = knownIdsByWorkspace.get(dir) || new Set();
@@ -1113,25 +1181,30 @@ async function main() {
     sessionId = resumeId;
     workspaceDir = findWorkspaceDirForSessionId(workspaceDirs, sessionId) || workspaceDirs[0] || null;
   } else {
-    const byProc = await resolveSessionFromProcessGroup();
-    if (byProc?.id) {
-      sessionId = byProc.id;
-      workspaceDir = byProc.workspaceDir;
-    } else if (resumeFlag) {
-      const latest = pickLatestSessionAcross(workspaceDirs);
-      sessionId = latest?.id || null;
-      workspaceDir = latest?.workspaceDir || workspaceDirs[0] || null;
+    let abortResolve = false;
+    const shouldAbort = () => abortResolve;
+
+    const byProcPromise = resolveSessionFromProcessGroup(shouldAbort, 20);
+
+    let picked = null;
+    if (resumeFlag) {
+      // For --resume without an explicit id, don't block startup too long on ps/lsof.
+      // Prefer process-group resolution when it is fast; otherwise fall back to latest.
+      picked = await Promise.race([
+        byProcPromise,
+        sleep(400).then(() => null),
+      ]);
+      if (!picked) picked = pickLatestSessionAcross(workspaceDirs);
     } else {
-      const fresh = await waitForNewSessionAcross(workspaceDirs, knownIdsByWorkspace, START_MS);
-      if (fresh) {
-        sessionId = fresh.id;
-        workspaceDir = fresh.workspaceDir;
-      } else {
-        const latest = pickLatestSessionAcross(workspaceDirs);
-        sessionId = latest?.id || null;
-        workspaceDir = latest?.workspaceDir || workspaceDirs[0] || null;
-      }
+      const freshPromise = waitForNewSessionAcross(workspaceDirs, knownIdsByWorkspace, START_MS, shouldAbort);
+      picked = await firstNonNull([byProcPromise, freshPromise]);
+      if (!picked) picked = pickLatestSessionAcross(workspaceDirs);
     }
+
+    abortResolve = true;
+
+    sessionId = picked?.id || null;
+    workspaceDir = picked?.workspaceDir || workspaceDirs[0] || null;
   }
 
   if (!sessionId || !workspaceDir) return;
@@ -1148,8 +1221,8 @@ async function main() {
   let compacting = false;
   let lastRenderAt = 0;
   let lastRenderedLine = '';
-  const gitBranch = resolveGitBranch(cwd);
-  const gitDiff = resolveGitDiffSummary(cwd);
+  let gitBranch = '';
+  let gitDiff = '';
 
   function renderNow() {
     const usedTokens = (last.cacheReadInputTokens || 0) + (last.contextCount || 0);
@@ -1172,79 +1245,93 @@ async function main() {
     }
   }
 
-  // Seed prompt-context usage from existing logs (important for resumed sessions and early calls).
-  // This avoids showing "Ctx: 0" until the next streaming event arrives.
-  try {
-    // Backward scan to find the most recent streaming-context entry for this session.
-    // The log can be large and shared across multiple sessions, so a small tail slice
-    // may miss older resumed sessions.
-    const MAX_SCAN_BYTES = 64 * 1024 * 1024; // 64 MiB
-    const CHUNK_BYTES = 1024 * 1024; // 1 MiB
+  // Initial render.
+  renderNow();
 
-    const fd = fs.openSync(LOG_PATH, 'r');
+  // Resolve git info asynchronously so startup isn't blocked on large repos.
+  setTimeout(() => {
     try {
-      const stat = fs.fstatSync(fd);
-      const size = Number(stat?.size ?? 0);
-      let pos = size;
-      let scanned = 0;
-      let remainder = '';
-      let seeded = false;
-
-      while (pos > 0 && scanned < MAX_SCAN_BYTES && !seeded) {
-        const readSize = Math.min(CHUNK_BYTES, pos);
-        const start = pos - readSize;
-        const buf = Buffer.alloc(readSize);
-        fs.readSync(fd, buf, 0, readSize, start);
-        pos = start;
-        scanned += readSize;
-
-        let text = buf.toString('utf8') + remainder;
-        let lines = String(text).split('\\n');
-        remainder = lines.shift() || '';
-        if (pos === 0 && remainder) {
-          lines.unshift(remainder);
-          remainder = '';
-        }
+      gitBranch = resolveGitBranch(cwd);
+      gitDiff = resolveGitDiffSummary(cwd);
+      renderNow();
+    } catch {}
+  }, 0).unref();
+
+  // Seed prompt-context usage from existing logs (important for resumed sessions).
+  // Do this asynchronously to avoid delaying the first statusline frame.
+  if (resumeFlag || resumeId) {
+    setTimeout(() => {
+      try {
+        // Backward scan to find the most recent streaming-context entry for this session.
+        // The log can be large and shared across multiple sessions.
+        const MAX_SCAN_BYTES = 64 * 1024 * 1024; // 64 MiB
+        const CHUNK_BYTES = 1024 * 1024; // 1 MiB
 
-        for (let i = lines.length - 1; i >= 0; i--) {
-          const line = String(lines[i] || '').trimEnd();
-          if (!line) continue;
-          if (!line.includes('Context:')) continue;
-          if (!line.includes('"sessionId":"' + sessionId + '"')) continue;
-          if (!line.includes('[Agent] Streaming result')) continue;
-          const ctxIndex = line.indexOf('Context: ');
-          if (ctxIndex === -1) continue;
-          const jsonStr = line.slice(ctxIndex + 'Context: '.length).trim();
-          let ctx;
-          try {
-            ctx = JSON.parse(jsonStr);
-          } catch {
-            continue;
+        const fd = fs.openSync(LOG_PATH, 'r');
+        try {
+          const stat = fs.fstatSync(fd);
+          const size = Number(stat?.size ?? 0);
+          let pos = size;
+          let scanned = 0;
+          let remainder = '';
+          let seeded = false;
+
+          while (pos > 0 && scanned < MAX_SCAN_BYTES && !seeded) {
+            const readSize = Math.min(CHUNK_BYTES, pos);
+            const start = pos - readSize;
+            const buf = Buffer.alloc(readSize);
+            fs.readSync(fd, buf, 0, readSize, start);
+            pos = start;
+            scanned += readSize;
+
+            let text = buf.toString('utf8') + remainder;
+            let lines = String(text).split('\\n');
+            remainder = lines.shift() || '';
+            if (pos === 0 && remainder) {
+              lines.unshift(remainder);
+              remainder = '';
+            }
+
+            for (let i = lines.length - 1; i >= 0; i--) {
+              const line = String(lines[i] || '').trimEnd();
+              if (!line) continue;
+              if (!line.includes('Context:')) continue;
+              if (!line.includes('"sessionId":"' + sessionId + '"')) continue;
+              if (!line.includes('[Agent] Streaming result')) continue;
+              const ctxIndex = line.indexOf('Context: ');
+              if (ctxIndex === -1) continue;
+              const jsonStr = line.slice(ctxIndex + 'Context: '.length).trim();
+              let ctx;
+              try {
+                ctx = JSON.parse(jsonStr);
+              } catch {
+                continue;
+              }
+              const cacheRead = Number(ctx?.cacheReadInputTokens ?? 0);
+              const contextCount = Number(ctx?.contextCount ?? 0);
+              const out = Number(ctx?.outputTokens ?? 0);
+              if (Number.isFinite(cacheRead)) last.cacheReadInputTokens = cacheRead;
+              if (Number.isFinite(contextCount)) last.contextCount = contextCount;
+              if (Number.isFinite(out)) last.outputTokens = out;
+              seeded = true;
+              break;
+            }
+
+            if (remainder.length > 8192) remainder = remainder.slice(-8192);
           }
-          const cacheRead = Number(ctx?.cacheReadInputTokens ?? 0);
-          const contextCount = Number(ctx?.contextCount ?? 0);
-          const out = Number(ctx?.outputTokens ?? 0);
-          if (Number.isFinite(cacheRead)) last.cacheReadInputTokens = cacheRead;
-          if (Number.isFinite(contextCount)) last.contextCount = contextCount;
-          if (Number.isFinite(out)) last.outputTokens = out;
-          seeded = true;
-          break;
+        } finally {
+          try {
+            fs.closeSync(fd);
+          } catch {}
         }
 
-        if (remainder.length > 8192) remainder = remainder.slice(-8192);
+        renderNow();
+      } catch {
+        // ignore
       }
-    } finally {
-      try {
-        fs.closeSync(fd);
-      } catch {}
-    }
-  } catch {
-    // ignore
+    }, 0).unref();
   }
 
-  // Initial render.
-  renderNow();
-
   // Watch session settings for autonomy/reasoning changes (cheap polling with mtime).
   let settingsMtimeMs = 0;
   setInterval(() => {
@@ -1331,7 +1418,7 @@ async function main() {
 main().catch(() => {});
 `;
 }
-function generateStatuslineWrapperScript(execTargetPath, monitorScriptPath) {
+function generateStatuslineWrapperScript(execTargetPath, monitorScriptPath, sessionsScriptPath) {
 	return `#!/usr/bin/env python3
 # Droid with Statusline (PTY proxy)
 # Auto-generated by droid-patch --statusline
@@ -1357,6 +1444,7 @@ import fcntl
 
 EXEC_TARGET = ${JSON.stringify(execTargetPath)}
 STATUSLINE_MONITOR = ${JSON.stringify(monitorScriptPath)}
+SESSIONS_SCRIPT = ${sessionsScriptPath ? JSON.stringify(sessionsScriptPath) : "None"}
 
 IS_APPLE_TERMINAL = os.environ.get("TERM_PROGRAM") == "Apple_Terminal"
 MIN_RENDER_INTERVAL_MS = 800 if IS_APPLE_TERMINAL else 400
@@ -1364,6 +1452,61 @@ QUIET_MS = 50  # Reduced to prevent statusline disappearing
 FORCE_REPAINT_INTERVAL_MS = 2000  # Force repaint every 2 seconds
 RESERVED_ROWS = 1
 
+BYPASS_FLAGS = {"--help", "-h", "--version", "-V"}
+BYPASS_COMMANDS = {"help", "version", "completion", "completions", "exec"}
+
+def _should_passthrough(argv):
+    # Any help/version flags before "--"
+    for a in argv:
+        if a == "--":
+            break
+        if a in BYPASS_FLAGS:
+            return True
+
+    # Top-level command token
+    end_opts = False
+    cmd = None
+    for a in argv:
+        if a == "--":
+            end_opts = True
+            continue
+        if (not end_opts) and a.startswith("-"):
+            continue
+        cmd = a
+        break
+
+    return cmd in BYPASS_COMMANDS
+
+def _exec_passthrough():
+    try:
+        os.execvp(EXEC_TARGET, [EXEC_TARGET] + sys.argv[1:])
+    except Exception as e:
+        sys.stderr.write(f"[statusline] passthrough failed: {e}\\n")
+        sys.exit(1)
+
+def _is_sessions_command(argv):
+    for a in argv:
+        if a == "--":
+            return False
+        if a == "--sessions":
+            return True
+    return False
+
+def _run_sessions():
+    if SESSIONS_SCRIPT and os.path.exists(SESSIONS_SCRIPT):
+        os.execvp("node", ["node", SESSIONS_SCRIPT])
+    else:
+        sys.stderr.write("[statusline] sessions script not found\\n")
+        sys.exit(1)
+
+# Handle --sessions command
+if _is_sessions_command(sys.argv[1:]):
+    _run_sessions()
+
+# Passthrough for non-interactive/meta commands (avoid clearing screen / PTY proxy)
+if (not sys.stdin.isatty()) or (not sys.stdout.isatty()) or _should_passthrough(sys.argv[1:]):
+    _exec_passthrough()
+
 ANSI_RE = re.compile(r"\\x1b\\[[0-9;]*m")
 RESET_SGR = "\\x1b[0m"
 
@@ -1975,9 +2118,6 @@ class CursorTracker:
 
 
 def main():
-    if not (sys.stdin.isatty() and sys.stdout.isatty()):
-        os.execv(EXEC_TARGET, [EXEC_TARGET] + sys.argv[1:])
-
     # Start from a clean viewport. Droid's TUI assumes a fresh screen; without this,
     # it can visually mix with prior shell output (especially when scrollback exists).
     try:
@@ -2125,7 +2265,7 @@ def main():
                         )
                         # Also detect scroll region changes with parameters (DECSTBM pattern ESC[n;mr)
                         if b"\\x1b[" in detect_buf and b"r" in detect_buf:
-                            if re.search(b"\\x1b\\[\\d*;?\\d*r", detect_buf):
+                            if re.search(b"\\x1b\\\\[[0-9]*;?[0-9]*r", detect_buf):
                                 needs_scroll_region_reset = True
                         if needs_scroll_region_reset:
                             renderer.force_repaint(True)
@@ -2261,13 +2401,13 @@ if __name__ == "__main__":
     main()
 `;
 }
-async function createStatuslineFiles(outputDir, execTargetPath, aliasName) {
+async function createStatuslineFiles(outputDir, execTargetPath, aliasName, sessionsScriptPath) {
 	if (!existsSync(outputDir)) await mkdir(outputDir, { recursive: true });
 	const monitorScriptPath = join(outputDir, `${aliasName}-statusline.js`);
 	const wrapperScriptPath = join(outputDir, aliasName);
 	await writeFile(monitorScriptPath, generateStatuslineMonitorScript());
 	await chmod(monitorScriptPath, 493);
-	await writeFile(wrapperScriptPath, generateStatuslineWrapperScript(execTargetPath, monitorScriptPath));
+	await writeFile(wrapperScriptPath, generateStatuslineWrapperScript(execTargetPath, monitorScriptPath, sessionsScriptPath));
 	await chmod(wrapperScriptPath, 493);
 	return {
 		wrapperScript: wrapperScriptPath,
@@ -2275,6 +2415,269 @@ async function createStatuslineFiles(outputDir, execTargetPath, aliasName) {
 	};
 }
 
+//#endregion
+//#region src/sessions-patch.ts
+/**
+* Generate sessions browser script (Node.js)
+*/
+function generateSessionsBrowserScript(aliasName) {
+	return `#!/usr/bin/env node
+// Droid Sessions Browser - Interactive selector
+// Auto-generated by droid-patch
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execSync, spawn } = require('child_process');
+
+const FACTORY_HOME = path.join(require('os').homedir(), '.factory');
+const SESSIONS_ROOT = path.join(FACTORY_HOME, 'sessions');
+const ALIAS_NAME = ${JSON.stringify(aliasName)};
+
+// ANSI
+const CYAN = '\\x1b[36m';
+const GREEN = '\\x1b[32m';
+const YELLOW = '\\x1b[33m';
+const RED = '\\x1b[31m';
+const DIM = '\\x1b[2m';
+const RESET = '\\x1b[0m';
+const BOLD = '\\x1b[1m';
+const CLEAR = '\\x1b[2J\\x1b[H';
+const HIDE_CURSOR = '\\x1b[?25l';
+const SHOW_CURSOR = '\\x1b[?25h';
+
+function sanitizePath(p) {
+  return p.replace(/:/g, '').replace(/[\\\\/]/g, '-');
+}
+
+function parseSessionFile(jsonlPath, settingsPath) {
+  const sessionId = path.basename(jsonlPath, '.jsonl');
+  const stats = fs.statSync(jsonlPath);
+  
+  const result = {
+    id: sessionId,
+    title: '',
+    mtime: stats.mtimeMs,
+    model: '',
+    firstUserMsg: '',
+    lastUserMsg: '',
+    messageCount: 0,
+    lastTimestamp: '',
+  };
+
+  try {
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const lines = content.split('\\n').filter(l => l.trim());
+    const userMessages = [];
+    
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === 'session_start') {
+          result.title = obj.title || '';
+        } else if (obj.type === 'message') {
+          result.messageCount++;
+          if (obj.timestamp) result.lastTimestamp = obj.timestamp;
+          
+          const msg = obj.message || {};
+          if (msg.role === 'user' && Array.isArray(msg.content)) {
+            for (const c of msg.content) {
+              if (c && c.type === 'text' && c.text && !c.text.startsWith('<system-reminder>')) {
+                userMessages.push(c.text.slice(0, 150).replace(/\\n/g, ' ').trim());
+                break;
+              }
+            }
+          }
+        }
+      } catch {}
+    }
+    
+    if (userMessages.length > 0) {
+      result.firstUserMsg = userMessages[0];
+      result.lastUserMsg = userMessages.length > 1 ? userMessages[userMessages.length - 1] : '';
+    }
+  } catch {}
+
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+      result.model = settings.model || '';
+    } catch {}
+  }
+
+  return result;
+}
+
+function collectSessions() {
+  const cwd = process.cwd();
+  const cwdSanitized = sanitizePath(cwd);
+  const sessions = [];
+
+  if (!fs.existsSync(SESSIONS_ROOT)) return sessions;
+
+  for (const wsDir of fs.readdirSync(SESSIONS_ROOT)) {
+    if (wsDir !== cwdSanitized) continue;
+    
+    const wsPath = path.join(SESSIONS_ROOT, wsDir);
+    if (!fs.statSync(wsPath).isDirectory()) continue;
+
+    for (const file of fs.readdirSync(wsPath)) {
+      if (!file.endsWith('.jsonl')) continue;
+      
+      const sessionId = file.slice(0, -6);
+      const jsonlPath = path.join(wsPath, file);
+      const settingsPath = path.join(wsPath, sessionId + '.settings.json');
+
+      try {
+        const session = parseSessionFile(jsonlPath, settingsPath);
+        if (session.messageCount === 0 || !session.firstUserMsg) continue;
+        sessions.push(session);
+      } catch {}
+    }
+  }
+
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  return sessions.slice(0, 50);
+}
+
+function formatTime(ts) {
+  if (!ts) return '';
+  try {
+    const d = new Date(ts);
+    return d.toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' });
+  } catch {
+    return ts.slice(0, 16);
+  }
+}
+
+function truncate(s, len) {
+  if (!s) return '';
+  s = s.replace(/\\n/g, ' ');
+  return s.length > len ? s.slice(0, len - 3) + '...' : s;
+}
+
+function render(sessions, selected, offset, rows) {
+  const cwd = process.cwd();
+  const pageSize = rows - 6;
+  const visible = sessions.slice(offset, offset + pageSize);
+  
+  let out = CLEAR;
+  out += BOLD + 'Sessions: ' + RESET + DIM + cwd + RESET + '\\n';
+  out += DIM + '[↑/↓] Select  [Enter] Resume  [q] Quit' + RESET + '\\n\\n';
+
+  for (let i = 0; i < visible.length; i++) {
+    const s = visible[i];
+    const idx = offset + i;
+    const isSelected = idx === selected;
+    const prefix = isSelected ? GREEN + '▶ ' + RESET : '  ';
+    
+    const title = truncate(s.title || '(no title)', 35);
+    const time = formatTime(s.lastTimestamp);
+    const model = truncate(s.model, 20);
+    
+    if (isSelected) {
+      out += prefix + YELLOW + title + RESET + '\\n';
+      out += '    ' + DIM + 'ID: ' + RESET + CYAN + s.id + RESET + '\\n';
+      out += '    ' + DIM + 'Last: ' + time + ' | Model: ' + model + ' | ' + s.messageCount + ' msgs' + RESET + '\\n';
+      out += '    ' + DIM + 'First input: ' + RESET + truncate(s.firstUserMsg, 60) + '\\n';
+      if (s.lastUserMsg && s.lastUserMsg !== s.firstUserMsg) {
+        out += '    ' + DIM + 'Last input:  ' + RESET + truncate(s.lastUserMsg, 60) + '\\n';
+      }
+    } else {
+      out += prefix + title + DIM + ' (' + time + ')' + RESET + '\\n';
+    }
+  }
+
+  out += '\\n' + DIM + 'Page ' + (Math.floor(offset / pageSize) + 1) + '/' + Math.ceil(sessions.length / pageSize) + ' (' + sessions.length + ' sessions)' + RESET;
+  
+  process.stdout.write(out);
+}
+
+async function main() {
+  const sessions = collectSessions();
+  
+  if (sessions.length === 0) {
+    console.log(RED + 'No sessions with interactions found in current directory' + RESET);
+    process.exit(0);
+  }
+
+  if (!process.stdin.isTTY) {
+    for (const s of sessions) {
+      console.log(s.id + '  ' + (s.title || '') + '  ' + formatTime(s.lastTimestamp));
+    }
+    process.exit(0);
+  }
+
+  const rows = process.stdout.rows || 24;
+  const pageSize = rows - 6;
+  let selected = 0;
+  let offset = 0;
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdout.write(HIDE_CURSOR);
+  
+  render(sessions, selected, offset, rows);
+
+  process.stdin.on('data', (key) => {
+    const k = key.toString();
+    
+    if (k === 'q' || k === '\\x03') { // q or Ctrl+C
+      process.stdout.write(SHOW_CURSOR + CLEAR);
+      process.exit(0);
+    }
+    
+    if (k === '\\r' || k === '\\n') { // Enter
+      process.stdout.write(SHOW_CURSOR + CLEAR);
+      const session = sessions[selected];
+      console.log(GREEN + 'Resuming session: ' + session.id + RESET);
+      console.log(DIM + 'Using: ' + ALIAS_NAME + ' --resume ' + session.id + RESET + '\\n');
+      const child = spawn(ALIAS_NAME, ['--resume', session.id], { stdio: 'inherit' });
+      child.on('exit', (code) => process.exit(code || 0));
+      return;
+    }
+    
+    if (k === '\\x1b[A' || k === 'k') { // Up
+      if (selected > 0) {
+        selected--;
+        if (selected < offset) offset = Math.max(0, offset - 1);
+      }
+    } else if (k === '\\x1b[B' || k === 'j') { // Down
+      if (selected < sessions.length - 1) {
+        selected++;
+        if (selected >= offset + pageSize) offset++;
+      }
+    } else if (k === '\\x1b[5~') { // Page Up
+      selected = Math.max(0, selected - pageSize);
+      offset = Math.max(0, offset - pageSize);
+    } else if (k === '\\x1b[6~') { // Page Down
+      selected = Math.min(sessions.length - 1, selected + pageSize);
+      offset = Math.min(Math.max(0, sessions.length - pageSize), offset + pageSize);
+    }
+    
+    render(sessions, selected, offset, rows);
+  });
+
+  process.on('SIGINT', () => {
+    process.stdout.write(SHOW_CURSOR + CLEAR);
+    process.exit(0);
+  });
+}
+
+main();
+`;
+}
+/**
+* Create sessions browser script file
+*/
+async function createSessionsScript(outputDir, aliasName) {
+	if (!existsSync(outputDir)) await mkdir(outputDir, { recursive: true });
+	const sessionsScriptPath = join(outputDir, `${aliasName}-sessions.js`);
+	await writeFile(sessionsScriptPath, generateSessionsBrowserScript(aliasName));
+	await chmod(sessionsScriptPath, 493);
+	return { sessionsScript: sessionsScriptPath };
+}
+
 //#endregion
 //#region src/cli.ts
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -2327,13 +2730,14 @@ function findDefaultDroidPath() {
 	for (const p of paths) if (existsSync(p)) return p;
 	return join(home, ".droid", "bin", "droid");
 }
-bin("droid-patch", "CLI tool to patch droid binary with various modifications").package("droid-patch", version).option("--is-custom", "Patch isCustom:!0 to isCustom:!1 (enable context compression for custom models)").option("--skip-login", "Inject a fake FACTORY_API_KEY to bypass login requirement (no real key needed)").option("--api-base <url>", "Replace API URL (standalone: binary patch, max 22 chars; with --websearch: proxy forward target, no limit)").option("--websearch", "Enable local WebSearch proxy (each instance runs own proxy, auto-cleanup on exit)").option("--statusline", "Enable a Claude-style statusline (terminal UI)").option("--standalone", "Standalone mode: mock non-LLM Factory APIs (use with --websearch)").option("--reasoning-effort", "Enable reasoning effort for custom models (set to high, enable UI selector)").option("--disable-telemetry", "Disable telemetry and Sentry error reporting (block data uploads)").option("--dry-run", "Verify patches without actually modifying the binary").option("-p, --path <path>", "Path to the droid binary").option("-o, --output <dir>", "Output directory for patched binary").option("--no-backup", "Do not create backup of original binary").option("-v, --verbose", "Enable verbose output").argument("[alias]", "Alias name for the patched binary").action(async (options, args) => {
+bin("droid-patch", "CLI tool to patch droid binary with various modifications").package("droid-patch", version).option("--is-custom", "Patch isCustom:!0 to isCustom:!1 (enable context compression for custom models)").option("--skip-login", "Inject a fake FACTORY_API_KEY to bypass login requirement (no real key needed)").option("--api-base <url>", "Replace API URL (standalone: binary patch, max 22 chars; with --websearch: proxy forward target, no limit)").option("--websearch", "Enable local WebSearch proxy (each instance runs own proxy, auto-cleanup on exit)").option("--statusline", "Enable a Claude-style statusline (terminal UI)").option("--sessions", "Enable sessions browser (--sessions flag in alias)").option("--standalone", "Standalone mode: mock non-LLM Factory APIs (use with --websearch)").option("--reasoning-effort", "Enable reasoning effort for custom models (set to high, enable UI selector)").option("--disable-telemetry", "Disable telemetry and Sentry error reporting (block data uploads)").option("--dry-run", "Verify patches without actually modifying the binary").option("-p, --path <path>", "Path to the droid binary").option("-o, --output <dir>", "Output directory for patched binary").option("--no-backup", "Do not create backup of original binary").option("-v, --verbose", "Enable verbose output").argument("[alias]", "Alias name for the patched binary").action(async (options, args) => {
 	const alias = args?.[0];
 	const isCustom = options["is-custom"];
 	const skipLogin = options["skip-login"];
 	const apiBase = options["api-base"];
 	const websearch = options["websearch"];
 	const statusline = options["statusline"];
+	const sessions = options["sessions"];
 	const standalone = options["standalone"];
 	const websearchTarget = websearch ? apiBase || "https://api.factory.ai" : void 0;
 	const reasoningEffort = options["reasoning-effort"];
@@ -2368,7 +2772,10 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 			execTargetPath = wrapperScript;
 		}
 		if (statusline) {
-			const { wrapperScript } = await createStatuslineFiles(join(homedir(), ".droid-patch", "statusline"), execTargetPath, alias);
+			const statuslineDir = join(homedir(), ".droid-patch", "statusline");
+			let sessionsScript;
+			if (sessions) sessionsScript = (await createSessionsScript(statuslineDir, alias)).sessionsScript;
+			const { wrapperScript } = await createStatuslineFiles(statuslineDir, execTargetPath, alias, sessionsScript);
 			execTargetPath = wrapperScript;
 		}
 		const aliasResult = await createAliasForWrapper(execTargetPath, alias, verbose);
@@ -2379,6 +2786,7 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 			apiBase: apiBase || null,
 			websearch: !!websearch,
 			statusline: !!statusline,
+			sessions: !!sessions,
 			reasoningEffort: false,
 			noTelemetry: false,
 			standalone
@@ -2574,7 +2982,10 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 				if (standalone) console.log(styleText("white", `  Standalone mode: enabled`));
 			}
 			if (statusline) {
-				const { wrapperScript } = await createStatuslineFiles(join(homedir(), ".droid-patch", "statusline"), execTargetPath, alias);
+				const statuslineDir = join(homedir(), ".droid-patch", "statusline");
+				let sessionsScript;
+				if (sessions) sessionsScript = (await createSessionsScript(statuslineDir, alias)).sessionsScript;
+				const { wrapperScript } = await createStatuslineFiles(statuslineDir, execTargetPath, alias, sessionsScript);
 				execTargetPath = wrapperScript;
 				console.log();
 				console.log(styleText("cyan", "Statusline enabled"));
@@ -2589,6 +3000,7 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 				apiBase: apiBase || null,
 				websearch: !!websearch,
 				statusline: !!statusline,
+				sessions: !!sessions,
 				reasoningEffort: !!reasoningEffort,
 				noTelemetry: !!noTelemetry,
 				standalone: !!standalone
@@ -2805,7 +3217,10 @@ bin("droid-patch", "CLI tool to patch droid binary with various modifications").
 				}
 			}
 			if (meta.patches.statusline) {
-				const { wrapperScript } = await createStatuslineFiles(join(homedir(), ".droid-patch", "statusline"), execTargetPath, meta.name);
+				const statuslineDir = join(homedir(), ".droid-patch", "statusline");
+				let sessionsScript;
+				if (meta.patches.sessions) sessionsScript = (await createSessionsScript(statuslineDir, meta.name)).sessionsScript;
+				const { wrapperScript } = await createStatuslineFiles(statuslineDir, execTargetPath, meta.name, sessionsScript);
 				execTargetPath = wrapperScript;
 				if (verbose) console.log(styleText("gray", `  Regenerated statusline wrapper`));
 			}