index.js

#!/usr/bin/env node

/**
 * OpenCode Starter (opencode-starter)
 * ───────────────────────────────────
 * A beautiful TUI for starting new and resuming past OpenCode sessions.
 *
 * Usage:
 *   opencode-starter             # Launch interactive TUI
 *   opencode-starter --list      # Print sessions as a table (no TUI)
 *   opencode-starter --list N    # Print the latest N sessions
 *   opencode-starter --version   # Show version
 *   opencode-starter --update    # Update to the latest version
 *   opencode-starter --help      # Show help
 *
 * Keyboard shortcuts (TUI mode):
 *   ↑/↓ or j/k     Navigate sessions
 *   Enter          Start new / resume selected session
 *   /              Start search (live filter)
 *   Esc            Clear search
 *   p              Filter by project (popup)
 *   s              Cycle sort: time → messages → project
 *   n              Start new session
 *   r              Rename a session (custom title)
 *   x / Delete     Delete the selected session
 *   c              Copy session ID to clipboard
 *   g / G          Jump to top / bottom
 *   Ctrl-D / U     Page down / up
 *   q / Ctrl-C     Quit
 */

const blessed = require('blessed');
const fs = require('fs');
const path = require('path');
const { spawn, execSync } = require('child_process');
const os = require('os');

// ─── OpenCode CLI Detection ─────────────────────────────────────────────────

function detectCLI() {
  // Just check if `opencode` is on PATH; we always invoke it as `opencode`.
  try {
    execSync('command -v opencode', { stdio: ['pipe', 'pipe', 'pipe'] });
    return { name: 'opencode', cmd: 'opencode' };
  } catch {
    return { name: 'opencode', cmd: 'opencode' };  // fall through; spawn will error if missing
  }
}

const CLI = detectCLI();

// ─── Color Palette (opencode-style) ─────────────────────────────────────────
// Mostly neutral, with restrained color accents — yellow for headings,
// green for user/success, blue for info, cyan for numbers, purple for keys,
// orange for warnings, red for danger. Inspired by the opencode CLI itself.
const C = {
  fg:        '#e5e7eb',  // primary text
  dim:       '#9ca3af',  // secondary text
  faint:     '#6b7280',  // tertiary
  rule:      '#3a3a3a',  // separators
  white:     '#ffffff',  // strong emphasis
  yellow:    '#eab308',  // section headings, highlights
  green:     '#22c55e',  // success, user/human messages
  blue:      '#60a5fa',  // info, paths, links
  cyan:      '#67e8f9',  // numbers, counts
  purple:    '#c084fc',  // hotkeys, accents
  orange:    '#fb923c',  // warnings, allow-mode badge
  red:       '#ef4444',  // danger, deletion
};

// Project name palette — tasteful colors so different projects are
// distinguishable at a glance, but not overwhelming.
const PROJECT_COLORS = [
  '#60a5fa', '#22c55e', '#eab308', '#c084fc',
  '#67e8f9', '#fb923c', '#f472b6', '#a3e635',
];

// ─── Paths ───────────────────────────────────────────────────────────────────
// OpenCode stores its data under XDG-style paths. On macOS / Linux the
// default lives under `~/.local/share/opencode/`.  Allow overrides via env.
const OPENCODE_DATA_DIR =
  process.env.OPENCODE_DATA_DIR ||
  process.env.OPENCODE_HOME ||
  path.join(os.homedir(), '.local', 'share', 'opencode');

const DB_PATH = path.join(OPENCODE_DATA_DIR, 'opencode.db');
const META_DIR = path.join(os.homedir(), '.opencode-starter');
const META_FILE = path.join(META_DIR, 'meta.json');

// OpenCode reads its global config from ~/.config/opencode/opencode.json.
// We modify just the `permission` block so users can switch between
// "ask every time" and "auto-approve everything" without leaving the TUI.
const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
const OPENCODE_CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');

// ─── OpenCode Config (permission mode) ───────────────────────────────
//   "ask"   = original behaviour, every tool call prompts you
//   "allow" = full bypass, never prompt
//   "deny"  = always refuse
// We treat "ask" as the unset/default state.

const PERMISSION_KEYS = ['edit', 'bash', 'webfetch'];
const PERMISSION_MODES = ['ask', 'allow', 'deny'];

function loadOpencodeConfig() {
  try {
    if (fs.existsSync(OPENCODE_CONFIG_FILE)) {
      return JSON.parse(fs.readFileSync(OPENCODE_CONFIG_FILE, 'utf-8'));
    }
  } catch (e) { /* corrupt file → start fresh, never overwrite blindly though */ }
  return null;
}

function saveOpencodeConfig(cfg) {
  try {
    if (!fs.existsSync(OPENCODE_CONFIG_DIR)) {
      fs.mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
    }
    fs.writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
    return true;
  } catch (e) {
    return false;
  }
}

// Returns one of "ask" | "allow" | "deny" | "mixed".
// "mixed" means edit/bash/webfetch don't all agree (custom config), so we
// surface that instead of pretending one mode is active.
function getCurrentPermissionMode() {
  const cfg = loadOpencodeConfig();
  if (!cfg || !cfg.permission) return 'ask';
  const vals = PERMISSION_KEYS.map(k => {
    const v = cfg.permission[k];
    if (typeof v === 'string') return v;
    if (v == null) return 'ask';
    return 'mixed';  // object form (per-command rules) — treat as advanced/mixed
  });
  const first = vals[0];
  return vals.every(v => v === first) ? first : 'mixed';
}

// Set every key in PERMISSION_KEYS to the same string value, preserving any
// other top-level config the user may have. Returns true on success.
function setPermissionMode(mode) {
  if (!PERMISSION_MODES.includes(mode)) {
    throw new Error(`Invalid permission mode: ${mode}`);
  }
  const cfg = loadOpencodeConfig() || {
    $schema: 'https://opencode.ai/config.json',
  };
  if (!cfg.permission || typeof cfg.permission !== 'object') cfg.permission = {};
  for (const k of PERMISSION_KEYS) cfg.permission[k] = mode;
  return saveOpencodeConfig(cfg);
}

// ─── Session Meta ────────────────────────────────────────────────────
// Stores user-defined customTitles for sessions in a simple JSON file.
// (OpenCode itself stores titles in SQLite; this is layered on top so a
//  rename here is reversible and never corrupts the DB.)

function loadMeta() {
  try {
    if (fs.existsSync(META_FILE)) {
      return JSON.parse(fs.readFileSync(META_FILE, 'utf-8'));
    }
  } catch (e) { /* corrupt file, start fresh */ }
  return { sessions: {} };
}

function saveMeta(meta) {
  try {
    if (!fs.existsSync(META_DIR)) fs.mkdirSync(META_DIR, { recursive: true });
    fs.writeFileSync(META_FILE, JSON.stringify(meta, null, 2), 'utf-8');
  } catch (e) { /* silently fail */ }
}

function getSessionMeta(meta, sessionId) {
  return meta.sessions[sessionId] || {};
}

function setSessionCustomTitle(meta, sessionId, title) {
  if (!meta.sessions[sessionId]) meta.sessions[sessionId] = {};
  if (title) {
    meta.sessions[sessionId].customTitle = title;
  } else {
    delete meta.sessions[sessionId].customTitle;
  }
  saveMeta(meta);
}

// ─── Data Layer ──────────────────────────────────────────────────────────────

function getProjectDisplayName(worktree) {
  // OpenCode's project.worktree is an absolute path (or "/" for the global
  // project). Strip user-home prefix and grab the last meaningful segment.
  if (!worktree || worktree === '/') return 'global';

  let p = worktree;
  // Remove home prefix
  const home = os.homedir();
  if (p.startsWith(home)) p = p.slice(home.length);
  // Strip leading slashes/dashes
  p = p.replace(/^[\/\\-]+/, '');

  if (!p) return '~';

  // Take the last path segment
  const parts = p.split(/[\/\\]/).filter(Boolean);
  if (parts.length === 0) return '~';

  // Skip well-known parent dirs (Desktop, Projects, etc) so we surface the
  // actual project folder name (mirrors claude-starter behaviour).
  const skipPrefixes = /^(Desktop|Documents|Projects|Downloads|dev|src|code|repos|work|home)$/i;
  while (parts.length > 1 && skipPrefixes.test(parts[0])) parts.shift();

  return parts[parts.length - 1] || worktree;
}

// ─── SQLite access ──────────────────────────────────────────────────────────
// Resolved lazily so unit tests can run without the native module being
// importable (e.g. CI without a build toolchain).

let _Database = null;
function getDatabaseClass() {
  if (_Database) return _Database;
  try {
    _Database = require('better-sqlite3');
  } catch (e) {
    throw new Error(
      'better-sqlite3 is required to read OpenCode sessions.\n'
      + 'Install with:  npm install -g opencode-starter\n'
      + 'Underlying error: ' + e.message,
    );
  }
  return _Database;
}

function openDatabase(dbPath) {
  if (!fs.existsSync(dbPath)) {
    throw new Error(`OpenCode database not found at ${dbPath}\n`
      + `Set OPENCODE_DATA_DIR if it lives elsewhere.`);
  }
  const Database = getDatabaseClass();
  // readonly to be safe; fileMustExist checked above
  return new Database(dbPath, { readonly: true, fileMustExist: true });
}

// Extract a short text snippet from an opencode `part.data` JSON blob.
// Parts have type like "text", "step-start", "tool", "reasoning", etc.
function extractPartText(partRow) {
  try {
    const d = JSON.parse(partRow.data);
    if (d.type === 'text' && typeof d.text === 'string') return d.text;
  } catch { /* skip */ }
  return '';
}

function summarizeProject(worktree) {
  return {
    name: getProjectDisplayName(worktree),
    worktree,
  };
}

// Build the per-session aggregate data we display.
function loadAllSessions(dbPath) {
  const db = openDatabase(dbPath || DB_PATH);

  try {
    // Pull all sessions with project info joined in
    const sessions = db.prepare(`
      SELECT
        s.id              AS session_id,
        s.project_id      AS project_id,
        s.title           AS title,
        s.directory       AS directory,
        s.version         AS version,
        s.time_created    AS time_created,
        s.time_updated    AS time_updated,
        s.time_archived   AS time_archived,
        s.parent_id       AS parent_id,
        p.worktree        AS worktree
      FROM session s
      LEFT JOIN project p ON p.id = s.project_id
      WHERE s.time_archived IS NULL
      ORDER BY s.time_updated DESC
    `).all();

    // Per-session message counts
    const msgCountStmt = db.prepare(
      'SELECT COUNT(*) AS c FROM message WHERE session_id = ?',
    );
    // First text part (first user message) — a small heuristic for "topic".
    // Order by message.time_created then part.time_created, find first
    // text part where parent message is role=user.
    const firstTextStmt = db.prepare(`
      SELECT p.data AS data
      FROM part p
      INNER JOIN message m ON m.id = p.message_id
      WHERE p.session_id = ?
        AND json_extract(p.data, '$.type') = 'text'
        AND json_extract(m.data, '$.role') = 'user'
      ORDER BY m.time_created ASC, p.time_created ASC
      LIMIT 1
    `);

    const result = [];
    for (const r of sessions) {
      const messages = msgCountStmt.get(r.session_id).c;

      // Skip sessions with zero messages — these are aborted before any input.
      if (!messages) continue;

      let topic = '';
      try {
        const row = firstTextStmt.get(r.session_id);
        if (row) topic = extractPartText({ data: row.data });
      } catch { /* skip */ }
      topic = (topic || '').replace(/\s+/g, ' ').trim();
      if (topic.length > 200) topic = topic.substring(0, 200) + '…';

      const projectName = getProjectDisplayName(r.worktree || r.directory);
      result.push({
        sessionId: r.session_id,
        title: r.title || '',
        topic: topic || r.title || '(no messages)',
        project: projectName,
        worktree: r.worktree || '',
        directory: r.directory || '',
        version: r.version || '',
        firstTs: r.time_created,
        lastTs: r.time_updated,
        estimatedMessages: messages,
        totalMessages: messages,
        parentId: r.parent_id || null,
        // filled by loadSessionDetail
        userMessages: null,
        assistantSnippets: null,
        toolsUsed: null,
        _detailLoaded: false,
      });
    }
    return result;
  } finally {
    try { db.close(); } catch { /* ignore */ }
  }
}

function loadSessionDetail(session, dbPath) {
  if (session._detailLoaded) return session;

  const db = openDatabase(dbPath || DB_PATH);
  try {
    const messages = db.prepare(`
      SELECT id, data, time_created
      FROM message
      WHERE session_id = ?
      ORDER BY time_created ASC, id ASC
    `).all(session.sessionId);

    const partsBySession = db.prepare(`
      SELECT message_id, data, time_created
      FROM part
      WHERE session_id = ?
      ORDER BY time_created ASC, id ASC
    `).all(session.sessionId);

    // group parts by message_id
    const partsByMsg = new Map();
    for (const p of partsBySession) {
      if (!partsByMsg.has(p.message_id)) partsByMsg.set(p.message_id, []);
      partsByMsg.get(p.message_id).push(p);
    }

    const userMessages = [];
    const assistantSnippets = [];
    const toolsUsed = new Set();

    for (const m of messages) {
      let role = '';
      try { role = JSON.parse(m.data).role || ''; } catch { /* skip */ }

      const parts = partsByMsg.get(m.id) || [];
      let text = '';
      for (const p of parts) {
        try {
          const d = JSON.parse(p.data);
          if (d.type === 'text' && typeof d.text === 'string') {
            text += (text ? ' ' : '') + d.text;
          } else if (d.type === 'tool' && d.tool) {
            toolsUsed.add(d.tool);
          }
        } catch { /* skip */ }
      }

      text = text.replace(/\s+/g, ' ').trim();
      if (!text) continue;

      if (role === 'user') {
        userMessages.push(text.substring(0, 300));
      } else if (role === 'assistant') {
        assistantSnippets.push(text.substring(0, 400));
      }
    }

    session.userMessages = userMessages;
    session.assistantSnippets = assistantSnippets;
    session.totalMessages = messages.length;
    session.estimatedMessages = messages.length;
    session.toolsUsed = Array.from(toolsUsed);
    session._detailLoaded = true;

    if (userMessages.length > 0 && (!session.topic || session.topic === '(no messages)')) {
      let topic = userMessages[0].replace(/\n/g, ' ').trim();
      if (topic.length > 120) topic = topic.substring(0, 120) + '…';
      session.topic = topic;
    }
  } finally {
    try { db.close(); } catch { /* ignore */ }
  }
  return session;
}

function deleteSessionFromDb(sessionId, dbPath) {
  // Open writable for this operation only
  const Database = getDatabaseClass();
  const target = dbPath || DB_PATH;
  if (!fs.existsSync(target)) return false;
  const db = new Database(target);
  try {
    // FK cascades from session -> message -> part should clean dependent rows.
    const info = db.prepare('DELETE FROM session WHERE id = ?').run(sessionId);
    return info.changes > 0;
  } finally {
    try { db.close(); } catch { /* ignore */ }
  }
}

// ─── Formatting Helpers ──────────────────────────────────────────────────────

function formatTimestamp(ts) {
  if (!ts) return 'unknown';
  const d = new Date(typeof ts === 'number' ? ts : ts);
  if (isNaN(d.getTime())) return 'unknown';
  const now = new Date();
  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
  const targetStart = new Date(d.getFullYear(), d.getMonth(), d.getDate());
  const diffDays = Math.round((todayStart.getTime() - targetStart.getTime()) / 86400000);
  const time = d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
  if (diffDays === 0) return `Today ${time}`;
  if (diffDays === 1) return `Yesterday ${time}`;
  if (diffDays < 7 && diffDays > 0) return `${diffDays}d ago ${time}`;
  if (diffDays < 365 && diffDays > 0) return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
  return d.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
}

function formatCount(n) {
  if (n < 1000) return String(n);
  if (n < 1000000) return `${(n / 1000).toFixed(1)}k`;
  return `${(n / 1000000).toFixed(1)}M`;
}

function getProjectColor(projectName, colorMap) {
  if (!colorMap.has(projectName)) {
    colorMap.set(projectName, PROJECT_COLORS[colorMap.size % PROJECT_COLORS.length]);
  }
  return colorMap.get(projectName);
}

function esc(text) {
  return String(text).replace(/\{/g, '\\{');
}

// ─── CLI Mode (--list) ───────────────────────────────────────────────────────

function runListMode(limit) {
  const sessions = loadAllSessions();
  const display = sessions.slice(0, limit || 30);
  const A = {
    reset:  '\x1b[0m',
    dim:    '\x1b[2m',
    bold:   '\x1b[1m',
    white:  '\x1b[97m',
    gray:   '\x1b[37m',
    yellow: '\x1b[33m',
    cyan:   '\x1b[36m',
    blue:   '\x1b[94m',
    purple: '\x1b[95m',
    green:  '\x1b[32m',
  };
  console.log(`\n${A.bold}${A.yellow}OpenCode Sessions${A.reset}  ${A.dim}${sessions.length} total · showing ${display.length}${A.reset}\n`);
  console.log(`${A.dim}${'─'.repeat(100)}${A.reset}`);
  console.log(`${A.bold}${A.gray}${'#'.padStart(3)}  ${'Time'.padEnd(18)} ${'Project'.padEnd(20)} ${'Msgs'.padStart(5)}  Topic${A.reset}`);
  console.log(`${A.dim}${'─'.repeat(100)}${A.reset}`);
  display.forEach((s, i) => {
    console.log(
      `${A.dim}${`${i + 1}`.padStart(3)}${A.reset}  `
      + `${A.gray}${formatTimestamp(s.lastTs).padEnd(18)}${A.reset} `
      + `${A.blue}${s.project.substring(0, 19).padEnd(20)}${A.reset} `
      + `${A.cyan}${formatCount(s.estimatedMessages).padStart(5)}${A.reset}  `
      + `${A.white}${(s.title || s.topic).substring(0, 50)}${A.reset}`,
    );
  });
  console.log(`${A.dim}${'─'.repeat(100)}${A.reset}`);
  console.log(`\n${A.dim}Resume:${A.reset} ${A.purple}${CLI.name} -s <session-id> -c${A.reset}\n`);
}

// ─── TUI Application ────────────────────────────────────────────────────────

function createApp() {
  const allSessions = loadAllSessions();
  const meta = loadMeta();

  // Apply meta customTitles — these override the DB title.
  for (const session of allSessions) {
    const sm = meta.sessions[session.sessionId];
    if (sm && sm.customTitle) session.customTitle = sm.customTitle;
  }

  let filteredSessions = [...allSessions];
  let selectedIndex = -1;  // -1 = "New Session", 0+ = session index
  let filterText = '';
  let isSearchMode = false;
  let sortMode = 'time';

  const projectColorMap = new Map();
  const uniqueProjects = [...new Set(allSessions.map(s => s.project))];
  uniqueProjects.forEach(p => getProjectColor(p, projectColorMap));

  const screen = blessed.screen({
    smartCSR: false,
    fastCSR: false,
    title: 'OpenCode Starter',
    fullUnicode: true,
    autoPadding: true,
    dockBorders: true,
  });
  // Don't force a bg — follow the terminal, like opencode itself does.

  const header = blessed.box({
    parent: screen, top: 0, left: 0, width: '100%', height: 3,
    tags: true, style: { fg: 'white' },
  });

  function updateHeader() {
    const title = '{bold}{#eab308-fg}OpenCode Starter{/}';
    const count = `{#67e8f9-fg}${filteredSessions.length}{/}{#6b7280-fg}/${allSessions.length} sessions{/}`;
    const proj = `{#60a5fa-fg}${uniqueProjects.length}{/}{#6b7280-fg} projects{/}`;
    const sort = `{#c084fc-fg}[${sortMode}]{/}`;
    // Live permission mode badge
    const mode = getCurrentPermissionMode();
    const modeColor = mode === 'allow' ? '#fb923c'   // orange — heads-up, no prompts
                     : mode === 'deny'  ? '#ef4444'   // red — blocking
                     : mode === 'mixed' ? '#eab308'   // yellow — partial
                                        : '#22c55e';  // green — safe default (ask)
    const modePrefix = mode === 'allow' ? '! ' : mode === 'deny' ? '✕ ' : '';
    const modeBadge = `{${modeColor}-fg}${modePrefix}${mode}{/}`;
    const search = isSearchMode
      ? `{#eab308-fg}/ ${filterText}▌{/}`
      : (filterText ? `{#9ca3af-fg}/ ${filterText}{/}` : '');
    let parts = [title, count, proj, sort, modeBadge];
    if (search) parts.push(search);
    header.setContent(`\n ${parts.join(' {#3a3a3a-fg}│{/} ')}`);
  }

  blessed.line({ parent: screen, top: 3, left: 0, width: '100%', orientation: 'horizontal', style: { fg: '#3a3a3a' } });

  const listPanel = blessed.list({
    parent: screen,
    top: 4, left: 0, width: '50%', height: '100%-7',
    tags: true,
    scrollable: true,
    alwaysScroll: true,
    scrollbar: { ch: '▐', style: { fg: '#6b7280' } },
    style: {
      fg: '#e5e7eb',
      selected: { bg: '#eab308', fg: 'black', bold: true },
    },
    keys: false,
    vi: false,
    mouse: true,
    interactive: true,
  });

  blessed.line({ parent: screen, top: 4, left: '50%', height: '100%-7', orientation: 'vertical', style: { fg: '#3a3a3a' } });

  const detailPanel = blessed.box({
    parent: screen,
    top: 4, left: '50%+1', width: '50%-1', height: '100%-7',
    tags: true, scrollable: true, alwaysScroll: true,
    scrollbar: { ch: '▐', style: { fg: '#6b7280' } },
    style: {  },
    mouse: true,
  });

  blessed.line({ parent: screen, bottom: 2, left: 0, width: '100%', orientation: 'horizontal', style: { fg: '#3a3a3a' } });

  const footer = blessed.box({
    parent: screen, bottom: 0, left: 0, width: '100%', height: 2,
    tags: true, style: { fg: '#e5e7eb' },
  });

  function updateFooter() {
    if (isSearchMode) {
      const keys = [
        '{#c084fc-fg}{bold}↵{/} {#9ca3af-fg}Confirm{/}',
        '{#c084fc-fg}{bold}↑↓{/} {#9ca3af-fg}Navigate{/}',
        '{#c084fc-fg}{bold}⌫{/} {#9ca3af-fg}Delete char{/}',
        '{#c084fc-fg}{bold}Esc{/} {#9ca3af-fg}Clear{/}',
      ];
      footer.setContent(`\n ${keys.join(' {#3a3a3a-fg}│{/} ')}`);
      return;
    }
    const keys = [
      '{#c084fc-fg}{bold}n{/} {#9ca3af-fg}New{/}',
      '{#c084fc-fg}{bold}↵{/} {#9ca3af-fg}Resume{/}',
      '{#c084fc-fg}{bold}m{/} {#9ca3af-fg}Mode{/}',
      '{#c084fc-fg}{bold}/{/} {#9ca3af-fg}Search{/}',
      '{#c084fc-fg}{bold}p{/} {#9ca3af-fg}Project{/}',
      '{#c084fc-fg}{bold}s{/} {#9ca3af-fg}Sort{/}',
      '{#c084fc-fg}{bold}c{/} {#9ca3af-fg}Copy ID{/}',
      '{#c084fc-fg}{bold}r{/} {#9ca3af-fg}Rename{/}',
      '{#ef4444-fg}{bold}x{/} {#9ca3af-fg}Delete{/}',
      '{#c084fc-fg}{bold}q{/} {#9ca3af-fg}Quit{/}',
    ];
    footer.setContent(`\n ${keys.join(' {#3a3a3a-fg}│{/} ')}`);
  }

  const NEW_SESSION_LABEL = ' {#22c55e-fg}{bold}+ New Conversation{/}';

  function refreshList() {
    const listW = Math.floor((screen.width || 100) / 2) - 2;

    const sessionItems = filteredSessions.map((session) => {
      const color = getProjectColor(session.project, projectColorMap);
      const proj = `{${color}-fg}${session.project.substring(0, 12).padEnd(12)}{/}`;
      const time = `{#9ca3af-fg}${formatTimestamp(session.lastTs).padEnd(16)}{/}`;
      const fixedLen = 1 + 12 + 1 + 16 + 1;
      const topicMaxLen = Math.max(10, listW - fixedLen);
      let topic = session.customTitle || session.title || session.topic || '';
      if (topic.length > topicMaxLen) topic = topic.substring(0, topicMaxLen) + '…';

      let label = ` ${proj} ${time} `;
      if (session.customTitle) {
        label += `{#d1d5db-fg}{bold}${esc(topic)}{/}`;
      } else {
        label += `{#e5e7eb-fg}${esc(topic)}{/}`;
      }
      return label;
    });

    const items = [NEW_SESSION_LABEL, ...sessionItems];
    listPanel.setItems(items);
    listPanel.select(selectedIndex + 1);  // +1: index 0 is "New Session"
    screen.render();
  }

  function renderDetail() {
    if (selectedIndex === -1) {
      let c = '';
      c += `\n {#22c55e-fg}{bold}Start a New Conversation{/}\n`;
      c += ` {#3a3a3a-fg}${'─'.repeat(44)}{/}\n\n`;
      c += ` {#e5e7eb-fg}Open a fresh OpenCode session and start{/}\n`;
      c += ` {#e5e7eb-fg}coding from scratch.{/}\n\n`;
      c += ` {#6b7280-fg}Working Dir{/}  {#60a5fa-fg}${process.cwd()}{/}\n`;
      c += ` {#6b7280-fg}CLI{/}          {#eab308-fg}${CLI.name}{/}\n`;
      c += ` {#6b7280-fg}Command{/}      {#9ca3af-fg}${CLI.name}{/}\n\n`;
      c += ` {#3a3a3a-fg}${'─'.repeat(44)}{/}\n`;
      c += ` {#c084fc-fg}{bold}↵ Enter{/}{#9ca3af-fg} or {/}{#c084fc-fg}{bold}n{/}{#9ca3af-fg} to launch{/}\n`;
      detailPanel.setContent(c);
      detailPanel.setScroll(0);
      return;
    }

    if (filteredSessions.length === 0 || !filteredSessions[selectedIndex]) {
      detailPanel.setContent('\n  {#6b7280-fg}No session selected{/}');
      return;
    }

    const session = filteredSessions[selectedIndex];
    try { loadSessionDetail(session); } catch (e) { /* show what we have */ }

    const sm = meta.sessions[session.sessionId];
    if (sm && sm.customTitle) session.customTitle = sm.customTitle;

    const color = getProjectColor(session.project, projectColorMap);
    let c = '';
    const sep = ` {#3a3a3a-fg}${'─'.repeat(44)}{/}`;

    c += `\n {${color}-fg}{bold}█ ${session.project}{/}\n`;
    if (session.customTitle) {
      c += ` {#d1d5db-fg}{bold}${esc(session.customTitle)}{/}\n`;
    } else if (session.title) {
      c += ` {#e5e7eb-fg}${esc(session.title)}{/}\n`;
    }
    c += sep + '\n\n';

    const fields = [
      ['Session', `{#60a5fa-fg}${session.sessionId}{/}`],
      ['Started', `{#9ca3af-fg}${session.firstTs ? new Date(session.firstTs).toLocaleString() : '?'}{/}`],
      ['Last active', `{#9ca3af-fg}${session.lastTs ? new Date(session.lastTs).toLocaleString() : '?'}{/}`],
      ['Messages', `{#67e8f9-fg}${session.totalMessages || session.estimatedMessages}{/}`],
    ];
    if (session.version) fields.push(['Version', `{#eab308-fg}v${session.version}{/}`]);
    if (session.worktree) fields.push(['Worktree', `{#60a5fa-fg}${session.worktree}{/}`]);
    if (session.parentId) fields.push(['Parent', `{#6b7280-fg}${session.parentId}{/}`]);

    for (const [label, value] of fields) {
      c += ` {#6b7280-fg}${label.padEnd(12)}{/} ${value}\n`;
    }

    if (session.toolsUsed && session.toolsUsed.length > 0) {
      c += `\n {#eab308-fg}{bold}Tools Used{/}\n`;
      const chips = session.toolsUsed.slice(0, 10)
        .map(t => `{#3a3a3a-fg}[{/}{#c084fc-fg}${t}{/}{#3a3a3a-fg}]{/}`)
        .join(' ');
      c += ` ${chips}\n`;
      if (session.toolsUsed.length > 10) c += ` {#6b7280-fg}+${session.toolsUsed.length - 10} more{/}\n`;
    }

    c += `\n {#eab308-fg}{bold}Conversation{/}\n`;
    c += sep + '\n';

    const msgs = (session.userMessages || []).slice(0, 10);
    const assists = (session.assistantSnippets || []);

    if (msgs.length === 0) {
      c += `\n  {#6b7280-fg}(no readable messages){/}\n`;
    } else {
      msgs.forEach((msg, i) => {
        const clean = esc(msg.replace(/\n/g, ' ').trim());
        const trunc = clean.length > 80 ? clean.substring(0, 80) + '…' : clean;
        c += `\n {#22c55e-fg}{bold}▎{/} {#e5e7eb-fg}{bold}${trunc}{/}\n`;
        if (assists[i]) {
          const aClean = esc(assists[i].replace(/\n/g, ' ').trim());
          const aTrunc = aClean.length > 80 ? aClean.substring(0, 80) + '…' : aClean;
          c += ` {#60a5fa-fg}▎{/} {#9ca3af-fg}${aTrunc}{/}\n`;
        }
      });
    }

    c += `\n${sep}`;
    c += `\n {#c084fc-fg}{bold}↵ Enter{/}{#9ca3af-fg} to resume this conversation{/}`;
    c += `\n {#60a5fa-fg}${CLI.name} -s ${session.sessionId} -c{/}\n`;

    detailPanel.setContent(c);
    detailPanel.setScroll(0);
  }

  function renderAll() {
    updateHeader();
    refreshList();
    renderDetail();
    updateFooter();
    listPanel.focus();
    screen.render();
  }

  function applyFilter() {
    if (!filterText) {
      filteredSessions = [...allSessions];
    } else {
      const terms = filterText.toLowerCase().split(/\s+/);
      filteredSessions = allSessions.filter(s => {
        const haystack = [
          s.project, s.title || '', s.topic || '', s.customTitle || '',
          s.sessionId, s.worktree || '',
          ...(s.userMessages || []),
        ].join(' ').toLowerCase();
        return terms.every(t => haystack.includes(t));
      });
    }
    selectedIndex = Math.min(selectedIndex, Math.max(-1, filteredSessions.length - 1));
    if (filterText && filteredSessions.length > 0) selectedIndex = 0;
    listPanel.childBase = 0;
    renderAll();
  }

  function cycleSort() {
    const modes = ['time', 'messages', 'project'];
    sortMode = modes[(modes.indexOf(sortMode) + 1) % modes.length];
    const sorters = {
      time: (a, b) => (b.lastTs || 0) - (a.lastTs || 0),
      messages: (a, b) => b.estimatedMessages - a.estimatedMessages,
      project: (a, b) => a.project.localeCompare(b.project) || (b.lastTs || 0) - (a.lastTs || 0),
    };
    allSessions.sort(sorters[sortMode]);
    selectedIndex = 0;
    applyFilter();
  }

  // ─── Project Picker ────────────────────────────────────────────────────
  let popupOpen = false;

  function showProjectPicker() {
    const projects = ['  All Projects', ...uniqueProjects.map(p => `  ${p}`)];
    const popup = blessed.list({
      parent: screen, top: 'center', left: 'center',
      width: Math.min(50, Math.max(...projects.map(p => p.length)) + 8),
      height: Math.min(projects.length + 4, 20),
      label: ' {bold}{#60a5fa-fg}Filter by Project{/} ',
      tags: true, border: { type: 'line' },
      style: {
        border: { fg: '#60a5fa' }, bg: '#0a0a0a', fg: '#e5e7eb',
        selected: { bg: '#60a5fa', fg: 'black', bold: true },
        label: { fg: '#60a5fa' },
      },
      items: projects, keys: true, vi: true, mouse: true,
    });
    popupOpen = true;
    popup.focus(); screen.render();
    popup.on('select', (item, index) => {
      filterText = index === 0 ? '' : uniqueProjects[index - 1];
      popup.destroy(); popupOpen = false; selectedIndex = 0; applyFilter();
    });
    popup.key(['escape', 'q'], () => { popup.destroy(); popupOpen = false; screen.render(); });
  }

  // ─── Selection / Navigation ────────────────────────────────────────────
  const _origSelect = listPanel.select.bind(listPanel);
  listPanel.select = function (index) {
    const sb = this.childBase;
    _origSelect(index);
    this.childBase = sb;
  };

  let suppressSelectEvent = false;
  listPanel.on('select item', (item, index) => {
    if (suppressSelectEvent) return;
    selectedIndex = index - 1;
    renderDetail(); updateHeader(); screen.render();
  });

  function moveSelection(delta) {
    const newIdx = selectedIndex + delta;
    if (newIdx >= -1 && newIdx < filteredSessions.length) {
      selectedIndex = newIdx;
      const listIdx = selectedIndex + 1;
      suppressSelectEvent = true;
      listPanel.select(listIdx);
      suppressSelectEvent = false;

      const base = listPanel.childBase;
      const visible = listPanel.height;
      if (listIdx < base) listPanel.childBase = listIdx;
      else if (listIdx >= base + visible) listPanel.childBase = listIdx - visible + 1;

      renderDetail(); updateHeader(); screen.render();
    }
  }

  screen.key(['down'], () => {
    if (renameMode || popupOpen) return;
    if (isSearchMode) { isSearchMode = false; updateHeader(); updateFooter(); screen.render(); }
    moveSelection(1);
  });
  screen.key(['up'], () => {
    if (renameMode || popupOpen) return;
    if (isSearchMode) { isSearchMode = false; updateHeader(); updateFooter(); screen.render(); }
    moveSelection(-1);
  });
  screen.key(['home'], () => {
    if (renameMode || popupOpen) return;
    selectedIndex = -1;
    suppressSelectEvent = true; listPanel.select(0); suppressSelectEvent = false;
    listPanel.childBase = 0;
    renderDetail(); updateHeader(); screen.render();
  });
  screen.key(['end'], () => {
    if (renameMode || popupOpen) return;
    selectedIndex = Math.max(0, filteredSessions.length - 1);
    suppressSelectEvent = true; listPanel.select(selectedIndex + 1); suppressSelectEvent = false;
    listPanel.childBase = Math.max(0, selectedIndex + 1 - listPanel.height + 1);
    renderDetail(); updateHeader(); screen.render();
  });
  screen.key(['pagedown', 'C-d'], () => {
    if (renameMode || popupOpen) return;
    moveSelection(Math.floor((listPanel.height || 20) / 2));
  });
  screen.key(['pageup', 'C-u'], () => {
    if (renameMode || popupOpen) return;
    moveSelection(-Math.floor((listPanel.height || 20) / 2));
  });

  screen.key(['/'], () => {
    if (renameMode || isSearchMode) return;
    isSearchMode = true;
    updateHeader(); updateFooter(); screen.render();
  });

  let searchJustConfirmed = false;

  screen.on('keypress', (ch, key) => {
    // Rename mode: capture all keys
    if (renameMode) {
      if (key.name === 'return' || key.name === 'enter') {
        const session = renameSession;
        const value = renameValue;
        closeRename();
        submitRename(session, value);
        return;
      }
      if (key.name === 'escape') {
        closeRename();
        listPanel.focus();
        screen.render();
        return;
      }
      if (key.name === 'backspace') {
        if (renameValue.length > 0) {
          renameValue = [...renameValue].slice(0, -1).join('');
          renderRenameInput();
        }
        return;
      }
      if (ch && ch.length >= 1 && ch.charCodeAt(0) >= 32 && !key.ctrl && !key.meta) {
        renameValue += ch;
        renderRenameInput();
      }
      return;
    }

    if (key.name === 'backspace') {
      if (filterText) {
        filterText = filterText.slice(0, -1);
        selectedIndex = -1;
        isSearchMode = !!filterText;
        applyFilter();
      } else if (isSearchMode) {
        isSearchMode = false;
        applyFilter();
      }
      return;
    }

    if (!isSearchMode && !popupOpen) {
      if (ch === 'j') { moveSelection(1); return; }
      if (ch === 'k') { moveSelection(-1); return; }
      if (ch === 'G') {
        selectedIndex = Math.max(0, filteredSessions.length - 1);
        suppressSelectEvent = true; listPanel.select(selectedIndex + 1); suppressSelectEvent = false;
        listPanel.childBase = Math.max(0, selectedIndex + 1 - listPanel.height + 1);
        renderDetail(); updateHeader(); screen.render();
        return;
      }
      if (ch === 'g') {
        selectedIndex = -1;
        suppressSelectEvent = true; listPanel.select(0); suppressSelectEvent = false;
        listPanel.childBase = 0;
        renderDetail(); updateHeader(); screen.render();
        return;
      }
    }

    if (!isSearchMode) return;
    if (key.name === 'return' || key.name === 'enter') {
      isSearchMode = false; searchJustConfirmed = true; renderAll(); return;
    }
    if (key.name === 'escape') { isSearchMode = false; filterText = ''; applyFilter(); return; }
    if (ch && ch.length === 1 && ch.charCodeAt(0) >= 32 && !key.ctrl && !key.meta) {
      filterText += ch; selectedIndex = -1; applyFilter();
    }
  });

  function resumeSession(session) {
    process.stdout.write('\x1b[0m');
    screen.destroy();
    console.log(`\n\x1b[1m⚡ Resuming OpenCode session\x1b[0m`);
    console.log(`\x1b[90m   Session: ${session.sessionId}\x1b[0m`);
    console.log(`\x1b[90m   Project: ${session.project}  │  Messages: ${session.estimatedMessages}\x1b[0m\n`);

    const cwd = (session.worktree && session.worktree !== '/' && fs.existsSync(session.worktree))
      ? session.worktree
      : (session.directory && fs.existsSync(session.directory) ? session.directory : process.cwd());

    const child = spawn(`${CLI.cmd} -s ${session.sessionId} -c`,
      { stdio: 'inherit', cwd, shell: true });
    child.on('error', (err) => {
      console.error(`\x1b[31mFailed to resume: ${err.message}\x1b[0m`);
      console.log(`\x1b[2mManual: ${CLI.name} -s ${session.sessionId} -c\x1b[0m`);
      process.exit(1);
    });
    child.on('exit', (code) => process.exit(code || 0));
  }

  function startNewSession() {
    process.stdout.write('\x1b[0m');
    screen.destroy();
    console.log(`\n\x1b[1m✨ Starting new OpenCode session\x1b[0m\n`);
    const child = spawn(CLI.cmd, { stdio: 'inherit', cwd: process.cwd(), shell: true });
    child.on('error', (err) => {
      console.error(`\x1b[31mFailed to start: ${err.message}\x1b[0m`);
      process.exit(1);
    });
    child.on('exit', (code) => process.exit(code || 0));
  }

  screen.key(['enter'], () => {
    if (renameMode) return;
    if (renameJustFinished) return;
    if (searchJustConfirmed) { searchJustConfirmed = false; return; }
    if (isSearchMode) { isSearchMode = false; renderAll(); return; }
    if (popupOpen) return;
    if (selectedIndex === -1) { startNewSession(); return; }
    if (filteredSessions.length === 0) return;
    resumeSession(filteredSessions[selectedIndex]);
  });

  screen.key(['n'], () => {
    if (renameMode || isSearchMode) return;
    startNewSession();
  });

  screen.key(['c'], () => {
    if (renameMode || isSearchMode) return;
    if (filteredSessions.length === 0 || selectedIndex < 0) return;
    const sid = filteredSessions[selectedIndex].sessionId;
    try {
      const proc = spawn('pbcopy', [], { stdio: ['pipe', 'ignore', 'ignore'] });
      proc.stdin.write(sid); proc.stdin.end();
      footer.setContent(`\n  {#22c55e-fg}{bold}✓ Copied:{/} {#d1d5db-fg}${sid}{/}`);
      screen.render();
      setTimeout(() => { updateFooter(); screen.render(); }, 1500);
    } catch (e) { /* silently fail */ }
  });

  // ─── Delete Session ────────────────────────────────────────────────────
  function deleteSession(session) {
    try {
      deleteSessionFromDb(session.sessionId);
      if (meta.sessions[session.sessionId]) {
        delete meta.sessions[session.sessionId];
        saveMeta(meta);
      }
      const allIdx = allSessions.indexOf(session);
      if (allIdx !== -1) allSessions.splice(allIdx, 1);
      const filtIdx = filteredSessions.indexOf(session);
      if (filtIdx !== -1) filteredSessions.splice(filtIdx, 1);
      if (selectedIndex >= filteredSessions.length) {
        selectedIndex = Math.max(-1, filteredSessions.length - 1);
      }
    } catch (e) { /* silently fail */ }
  }

  function showDeleteConfirm(session) {
    const topic = (session.customTitle || session.title || session.topic || '').substring(0, 30);
    const confirmPopup = blessed.box({
      parent: screen, top: 'center', left: 'center',
      width: 50, height: 9,
      label: ' {bold}{#ef4444-fg}Delete Session?{/} ',
      tags: true, border: { type: 'line' },
      style: {
        border: { fg: '#ef4444' }, bg: '#0a0a0a', fg: '#e5e7eb',
        label: { fg: '#ef4444' },
      },
      content:
        `\n  {#e5e7eb-fg}${esc(topic)}{/}\n`
        + `  {#6b7280-fg}${session.sessionId}{/}\n\n`
        + `  {#ef4444-fg}{bold}y{/}{#e5e7eb-fg} Delete  {/}{#6b7280-fg}n / Esc{/}{#e5e7eb-fg} Cancel{/}`,
    });
    popupOpen = true;
    confirmPopup.focus();
    screen.render();

    confirmPopup.key(['y'], () => {
      confirmPopup.destroy();
      popupOpen = false;
      deleteSession(session);
      footer.setContent(`\n  {#ef4444-fg}{bold}✗ Deleted:{/} {#6b7280-fg}${session.sessionId}{/}`);
      renderAll();
      setTimeout(() => { updateFooter(); screen.render(); }, 1500);
    });
    confirmPopup.key(['n', 'escape', 'q'], () => {
      confirmPopup.destroy();
      popupOpen = false;
      screen.render();
    });
  }

  screen.key(['x', 'delete'], () => {
    if (renameMode || isSearchMode || popupOpen) return;
    if (selectedIndex < 0 || selectedIndex >= filteredSessions.length) return;
    showDeleteConfirm(filteredSessions[selectedIndex]);
  });

  // ─── Rename Session ────────────────────────────────────────────────────
  let stringWidth;
  try { stringWidth = require('string-width'); }
  catch { stringWidth = (s) => String(s).length; }

  let renameMode = false;
  let renameJustFinished = false;
  let renameValue = '';
  let renameSession = null;
  let renamePopup = null;
  let renameDisplay = null;
  const renameMaxWidth = 46;

  function renderRenameInput() {
    let display = renameValue;
    while (stringWidth(display) > renameMaxWidth && display.length > 0) {
      display = display.substring(1);
    }
    renameDisplay.setContent(display + '▌');
    screen.render();
  }

  function showRenameInput(session) {
    renameSession = session;
    renameValue = session.customTitle || session.title || '';

    renamePopup = blessed.box({
      parent: screen, top: 'center', left: 'center',
      width: 52, height: 7,
      label: ' {bold}{#eab308-fg}Rename Session{/} ',
      tags: true, border: { type: 'line' },
      style: {
        border: { fg: '#eab308' }, bg: '#0a0a0a', fg: '#e5e7eb',
        label: { fg: '#eab308' },
      },
    });

    renameDisplay = blessed.box({
      parent: renamePopup,
      top: 1, left: 1, right: 1, height: 1,
      tags: false,
      style: { fg: 'white' },
    });

    blessed.box({
      parent: renamePopup,
      top: 3, left: 1, right: 1, height: 1,
      tags: true,
      style: { bg: '#0a0a0a' },
      content: '  {#22c55e-fg}{bold}Enter{/}{#e5e7eb-fg} Save  {/}{#6b7280-fg}Esc{/}{#e5e7eb-fg} Cancel{/}',
    });

    popupOpen = true;
    renameMode = true;
    renderRenameInput();
  }

  function closeRename() {
    renameMode = false;
    if (renamePopup) { renamePopup.destroy(); renamePopup = null; }
    popupOpen = false;
    renameSession = null;
    renameDisplay = null;
  }

  function submitRename(session, newTitle) {
    newTitle = (newTitle || '').trim();
    setSessionCustomTitle(meta, session.sessionId, newTitle);
    session.customTitle = newTitle;

    renderAll();

    renameJustFinished = true;
    setTimeout(() => { renameJustFinished = false; }, 200);

    footer.setContent(`\n  {#d1d5db-fg}{bold}✎ Renamed:{/} {#e5e7eb-fg}${esc(newTitle || '(cleared)')}{/}`);
    setTimeout(() => { updateFooter(); screen.render(); }, 1500);
  }

  screen.key(['r'], () => {
    if (isSearchMode || popupOpen) return;
    if (selectedIndex < 0 || selectedIndex >= filteredSessions.length) return;
    showRenameInput(filteredSessions[selectedIndex]);
  });

  // ─── Permission Mode Picker (m) ────────────────────────────────────────
  function showPermissionModePicker() {
    const current = getCurrentPermissionMode();
    const labels = {
      ask:   'ask    {#22c55e-fg}— prompt for every tool call (default){/}',
      allow: 'allow  {#fb923c-fg}— auto-approve everything (bypass){/}',
      deny:  'deny   {#ef4444-fg}— refuse all tool calls{/}',
    };
    const items = PERMISSION_MODES.map(m => {
      const checked = current === m ? '{#22c55e-fg}✓{/}' : ' ';
      return `  ${checked} {bold}{#e5e7eb-fg}${labels[m]}`;
    });
    if (current === 'mixed') {
      items.unshift('  {#9ca3af-fg}{bold}── currently: mixed (custom config) ──{/}');
    }

    const popup = blessed.list({
      parent: screen, top: 'center', left: 'center',
      width: 64,
      height: items.length + 4,
      label: ' {bold}{#fb923c-fg}Permission Mode{/} ',
      tags: true, border: { type: 'line' },
      style: {
        border: { fg: '#fb923c' }, bg: '#0a0a0a', fg: '#e5e7eb',
        selected: { bg: '#fb923c', fg: 'black', bold: true },
        label: { fg: '#fb923c' },
      },
      items, keys: true, vi: true, mouse: true,
    });
    popupOpen = true;
    popup.focus(); screen.render();

    const offset = current === 'mixed' ? 1 : 0;

    popup.on('select', (item, index) => {
      // Skip the header row when in "mixed" state
      if (current === 'mixed' && index === 0) return;
      const mode = PERMISSION_MODES[index - offset];
      if (!mode) return;
      const ok = setPermissionMode(mode);
      popup.destroy();
      popupOpen = false;
      if (ok) {
        const color = mode === 'allow' ? '#fb923c' : mode === 'deny' ? '#ef4444' : '#22c55e';
        const note = mode === 'allow' ? ' (no more prompts)' : '';
        footer.setContent(`\n  {${color}-fg}{bold}✓ Permission mode:{/} {${color}-fg}${mode}{/}{#6b7280-fg}${note}{/}`);
      } else {
        footer.setContent(`\n  {#ef4444-fg}{bold}✗ Failed to write{/} {#6b7280-fg}${OPENCODE_CONFIG_FILE}{/}`);
      }
      renderAll();
      setTimeout(() => { updateFooter(); screen.render(); }, 2000);
    });

    popup.key(['escape', 'q'], () => {
      popup.destroy();
      popupOpen = false;
      screen.render();
    });
  }

  screen.key(['m'], () => { if (!renameMode && !isSearchMode && !popupOpen) showPermissionModePicker(); });
  screen.key(['s'], () => { if (!renameMode && !isSearchMode) cycleSort(); });
  screen.key(['p'], () => { if (!renameMode && !isSearchMode) showProjectPicker(); });
  screen.key(['escape'], () => {
    if (renameMode) return;
    if (isSearchMode) { isSearchMode = false; filterText = ''; applyFilter(); return; }
    filterText = ''; selectedIndex = -1; applyFilter();
  });
  screen.key(['q', 'C-c'], () => {
    if (renameMode) return;
    process.stdout.write('\x1b[0m');
    screen.destroy();
    process.exit(0);
  });

  listPanel.removeAllListeners('element wheeldown');
  listPanel.removeAllListeners('element wheelup');

  function clampSelection() {
    const base = listPanel.childBase;
    const visible = listPanel.height;
    const listIdx = selectedIndex + 1;
    if (listIdx < base) {
      selectedIndex = base - 1;
      suppressSelectEvent = true; listPanel.select(base); suppressSelectEvent = false;
      renderDetail(); updateHeader();
    } else if (listIdx >= base + visible) {
      selectedIndex = base + visible - 1 - 1;
      suppressSelectEvent = true; listPanel.select(base + visible - 1); suppressSelectEvent = false;
      renderDetail(); updateHeader();
    }
  }

  listPanel.on('element wheeldown', () => {
    const maxBase = Math.max(0, listPanel.items.length - listPanel.height);
    if (listPanel.childBase < maxBase) {
      listPanel.childBase++;
      clampSelection();
      screen.render();
    }
  });
  listPanel.on('element wheelup', () => {
    if (listPanel.childBase > 0) {
      listPanel.childBase--;
      clampSelection();
      screen.render();
    }
  });

  detailPanel.on('wheeldown', () => { detailPanel.scroll(2); screen.render(); });
  detailPanel.on('wheelup', () => { detailPanel.scroll(-2); screen.render(); });

  renderAll();
  listPanel.focus();
}

// ─── Module Exports (for tests) ─────────────────────────────────────────────

if (typeof module !== 'undefined') {
  module.exports = {
    // Data helpers
    getProjectDisplayName,
    extractPartText,
    loadAllSessions,
    loadSessionDetail,
    deleteSessionFromDb,
    openDatabase,
    // Formatting
    formatTimestamp,
    formatCount,
    getProjectColor,
    esc,
    // Meta
    loadMeta,
    saveMeta,
    getSessionMeta,
    setSessionCustomTitle,
    // Constants
    PROJECT_COLORS,
    OPENCODE_DATA_DIR,
    DB_PATH,
    META_DIR,
    META_FILE,
    OPENCODE_CONFIG_DIR,
    OPENCODE_CONFIG_FILE,
    PERMISSION_KEYS,
    PERMISSION_MODES,
    // OpenCode config (permission mode)
    loadOpencodeConfig,
    saveOpencodeConfig,
    getCurrentPermissionMode,
    setPermissionMode,
    // CLI
    detectCLI,
    runListMode,
    createApp,
  };
}

// ─── Entry Point ─────────────────────────────────────────────────────────────

if (require.main === module) {
  const PKG = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
  const args = process.argv.slice(2);

  if (args.includes('--version') || args.includes('-v') || args.includes('-V')) {
    console.log(`opencode-starter v${PKG.version}`);
    process.exit(0);
  }

  if (args.includes('--update') || args.includes('-u')) {
    const A = {
      reset: '\x1b[0m', bold: '\x1b[1m',
      white: '\x1b[97m', gray: '\x1b[37m',
      red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m',
    };
    console.log(`\n${A.bold}${A.yellow}🔄 Checking for updates…${A.reset}\n`);
    try {
      const latest = execSync('npm view opencode-starter version 2>/dev/null', {
        stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000,
      }).toString().trim();

      if (latest === PKG.version) {
        console.log(`${A.green}✓ Already on the latest version (v${PKG.version})${A.reset}\n`);
        process.exit(0);
      }

      console.log(`${A.gray}  Current: v${PKG.version}${A.reset}`);
      console.log(`${A.green}  Latest:  v${latest}${A.reset}\n`);
      console.log(`${A.bold}${A.yellow}📦 Updating…${A.reset}\n`);
      try {
        execSync('npm install -g opencode-starter@latest', { stdio: 'inherit', timeout: 60000 });
        console.log(`\n${A.green}${A.bold}✓ Updated to v${latest}${A.reset}\n`);
      } catch (e) {
        console.error(`\n${A.red}✗ Update failed. Try manually:${A.reset}`);
        console.log(`${A.gray}  npm install -g opencode-starter@latest${A.reset}\n`);
        process.exit(1);
      }
    } catch (e) {
      console.error(`${A.red}✗ Could not check for updates (network error or npm not found)${A.reset}\n`);
      process.exit(1);
    }
    process.exit(0);
  }

  if (args.includes('--help') || args.includes('-h')) {
    console.log(`
\x1b[1m\x1b[33mOpenCode Starter\x1b[0m  \x1b[2mv${PKG.version}\x1b[0m

\x1b[1mUsage:\x1b[0m
  opencode-starter             Launch interactive TUI
  opencode-starter --list [N]  Print latest N sessions (default: 30)
  opencode-starter --version   Show version
  opencode-starter --update    Update to the latest version
  opencode-starter --help      Show this help

\x1b[1mTUI Keyboard Shortcuts:\x1b[0m
  \x1b[95m↑/↓ or j/k\x1b[0m     Navigate sessions
  \x1b[95mEnter\x1b[0m          Start new / resume selected session
  \x1b[95mn\x1b[0m              Start new session
  \x1b[95mm\x1b[0m              Permission mode picker (ask / allow / deny)
  \x1b[95m/\x1b[0m              Search (live filter)
  \x1b[95mp\x1b[0m              Filter by project
  \x1b[95ms\x1b[0m              Cycle sort mode (time/messages/project)
  \x1b[95mc\x1b[0m              Copy session ID
  \x1b[95mr\x1b[0m              Rename session
  \x1b[91mx / Delete\x1b[0m     Delete selected session
  \x1b[95mg / G\x1b[0m          Jump to top / bottom
  \x1b[95mCtrl-D / U\x1b[0m     Page down / up
  \x1b[95mEsc\x1b[0m            Clear filter
  \x1b[95mq / Ctrl-C\x1b[0m     Quit

\x1b[1mData source:\x1b[0m
  \x1b[94m${DB_PATH}\x1b[0m
`);
    process.exit(0);
  }

  if (args.includes('--list') || args.includes('-l')) {
    const limitIdx = args.indexOf('--list') !== -1 ? args.indexOf('--list') : args.indexOf('-l');
    const limit = parseInt(args[limitIdx + 1]) || 30;
    runListMode(limit);
    process.exit(0);
  }

  createApp();
}