agentp 1.13.0 → 2.0.0

package/bin/ocmux

@@ -3,29 +3,29 @@
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
+const http = require('http');
+const { URL } = require('url');
 const { spawnSync } = require('child_process');
 const os = require('os');
 const {
   SESSION,
-  readState,
   statefileFor,
   tuiPaneId,
   windowByDir,
   windowNameByIndex,
   activeWindowIndex,
-  paneCount,
-  listServers,
+  listProjects,
+  activateProject,
+  relaunchTui,
+  closeProjectWindow,
+  createProjectWindow,
   ensureSession,
   pinWindowName,
   sleep,
-  hashDir,
-  logfileFor,
-  URL_RE,
-  resurrectServer,
-  startServer,
-  getActiveServer,
-  activateServer,
+  tuiAttachCommand,
 } = require('../lib/ocmux');
+const { listSessions, createSession, createSessionWithModel, updateSession, listModels, switchModel, resolveModelRef, getAuthHeaders, sortSessionsByRecency, deleteSession, listAgents, getActiveSessions } = require('../lib/opencode');
+const projectState = require('../lib/project-state');
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -35,6 +35,7 @@ const { version } = require('../package.json');
 
 const SCRIPT = path.basename(process.argv[1] || 'ocmux');
 const HOME = os.homedir();
+const DEFAULT_SERVER = process.env.OCMUX_SERVER || 'http://localhost:4096';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -92,17 +93,9 @@ function resolveGitDir(startDir, requireDir, flagLabel) {
   if (!result.dir) {
     const label = requireDir ? '.git directory' : '.git entry';
     console.error(`Error: no ${label} found in ${startDir} or any of its parents.`);
-    console.error(`Run '${SCRIPT} serve' without ${flagLabel} to create a server in the current directory.`);
+    console.error(`Run '${SCRIPT} serve' without ${flagLabel} to create a project window in the current directory.`);
     process.exit(1);
   }
-
-  if (result.stateDir && result.stateDir !== result.dir) {
-    console.error(`Error: found an existing ocmux server in ${result.stateDir}.`);
-    console.error(`Refusing to create a new server at ${result.dir} because it is above that session.`);
-    console.error(`Move outside ${result.stateDir} or pass an explicit directory.`);
-    process.exit(1);
-  }
-
   return result.dir;
 }
 
@@ -135,446 +128,1147 @@ function resolveDir(arg) {
   process.exit(1);
 }
 
-function ensureTuiZoomed(windowIndex) {
-  const r = tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}|#{window_zoomed_flag}']);
-  if (r.status !== 0) return;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [wi, zoomed] = line.split('|');
-    if (parseInt(wi, 10) === windowIndex && zoomed === '1') return;
-  }
-  const paneId = tuiPaneId(windowIndex);
-  if (paneId) tmux(['resize-pane', '-Z', '-t', paneId]);
-}
-
-
-
-function outputUrl(url, dir, longMode) {
-  if (longMode) {
-    console.log(`${url} → ${dir}`);
-  } else {
-    console.log(url);
-  }
+// Health check: is a server answering on `server`? The server is user-managed
+// (started with `opencode serve`); this only verifies something is listening.
+function checkServer(server) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(`${server}/api/info`);
+    } catch {
+      return resolve(false);
+    }
+    const req = http.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname,
+      method: 'GET',
+      headers: getAuthHeaders(),
+    }, (res) => {
+      res.resume();
+      resolve(true); // any HTTP response means the server is up
+    });
+    req.setTimeout(3000, () => { req.destroy(); resolve(false); });
+    req.on('error', () => resolve(false));
+    req.end();
+  });
 }
 
-function printHelp() {
-  console.error(`Usage: ${SCRIPT} [-l] [<subcommand>] [<directory>]`);
-  console.error('');
-  console.error('Manage opencode server + TUI in tmux for project directories.');
-  console.error('');
-  console.error('Without arguments, searches upward from <directory> (default: $PWD)');
-  console.error("for .ocmux.json and switches to that server's tmux window.");
-  console.error('If <directory> is not a valid path, ocmux will match it against the');
-  console.error("basenames of existing sessions' directories. If exactly one matches,");
-  console.error('that session is used.');
-  console.error('');
-  console.error('Subcommands:');
-  console.error('  serve     Create a server in <directory> (default: $PWD) and attach a TUI.');
-  console.error('            Aliased as "new" for backwards compatibility.');
-  console.error('            Errors if one already exists there.');
-  console.error('            Warns if a parent directory already has a server.');
-  console.error('            --git  Use the nearest parent with a .git entry (file or dir).');
-  console.error('            --GIT  Use the nearest parent with a .git directory only.');
-  console.error('            Refuses to create above an existing .ocmux.json found while searching.');
-  console.error('            --print-logs  Pass --print-logs to opencode serve (prints server logs to stderr).');
-  console.error('  kill      Kill the server found upward from <directory>.');
-  console.error('            Removes its tmux window and state file.');
-  console.error('  resurrect Recover a dead server: kills the old window, removes the state file,');
-  console.error('            then creates a fresh server + TUI in the same directory.');
-  console.error('            Works even if no tmux window exists (stale state file).');
-  console.error('            --print-logs  Pass --print-logs to the new opencode serve.');
-  console.error('  list      List all running servers with their directories and URLs.');
-  console.error('  switch    Interactively select a server to switch to.');
-  console.error('            j/k or arrows to move, Enter/Space selects (menu stays open),');
-  console.error('            q or Ctrl+C quits. Prints the URL of the last selected server on exit.');
-  console.error('');
-  console.error('  --         Treat the next argument as a directory even if it matches');
-  console.error('            a subcommand name (e.g. "ocmux -- kill").');
-  console.error('');
-  console.error('Options:');
-  console.error('  -l       Long output: append " → <dir>" after the URL (serve/default).');
-  console.error('  --last   Print the URL of the active tmux window (last used server).');
-  console.error('  --print-logs  Pass --print-logs to opencode serve (prints server logs to stderr).');
-  console.error('  --version  Show version');
-  console.error('  -h       Show this help');
-  console.error('');
-  console.error('See also: agentp -- pipe prompts into OpenCode from stdin');
-  console.error('          tgagentp -- Telegram bridge for OpenCode (tgagentp --help)');
-  process.exit(0);
+function newestSessionId(sessions) {
+  if (!sessions || sessions.length === 0) return null;
+  const sorted = sortSessionsByRecency(sessions).filter(s => s && s.id);
+  return sorted.length > 0 ? sorted[0].id : null;
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: default — switch to an existing server
+// Shared list rendering (scrollable viewport + resize-aware)
 // ---------------------------------------------------------------------------
 
-function cmdSwitch(statefile, longMode) {
-  const serverDir = path.dirname(statefile);
-  const state = readState(statefile);
+// Visible window for a list rendered in `height` rows around `cursor`.
+// Pure (unit-tested). Returns { start, count }.
+function windowFor(len, cursor, height) {
+  if (len <= 0 || height <= 0) return { start: 0, count: 0 };
+  const count = Math.min(len, height);
+  if (len <= count) return { start: 0, count };
+  let start = cursor - Math.floor(count / 2);
+  start = Math.max(0, Math.min(start, len - count));
+  return { start, count };
+}
 
-  if (!state || !state.url || state.window_index == null) {
-    console.error(`Error: invalid state file ${statefile}`);
-    process.exit(1);
+// ── Small formatting / layout helpers ──────────────────────────────
+function centerIn(s, w) {
+  const str = String(s);
+  if (str.length >= w) return str.slice(0, w);
+  const left = Math.floor((w - str.length) / 2);
+  return ' '.repeat(left) + str + ' '.repeat(w - str.length - left);
+}
+function padLeft(s, w) {
+  const str = String(s);
+  return ' '.repeat(Math.max(0, w - str.length)) + str;
+}
+// Last-view stamp: HH:MM within the last 24h, else DD/MM/YYYY; '--:--' if unknown.
+function fmtClock(ts) {
+  if (!ts) return '--:--';
+  const d = new Date(ts);
+  if (Date.now() - ts < 24 * 3600 * 1000) {
+    return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
   }
+  return `${String(d.getDate()).padStart(2, '0')}/${String(d.getMonth() + 1).padStart(2, '0')}/${d.getFullYear()}`;
+}
+function fmtDuration(ms) {
+  const s = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}`;
+}
+function fmtTokens(n) {
+  if (n == null) return null;
+  const v = Number(n);
+  if (!Number.isFinite(v)) return null;
+  if (v >= 1e9) return (v / 1e9).toFixed(1) + 'B';
+  if (v >= 1e6) return (v / 1e6).toFixed(1) + 'M';
+  if (v >= 1e3) return Math.round(v / 1e3) + 'K';
+  return String(v);
+}
+function fmtCost(c) {
+  if (c == null) return null;
+  const v = Number(c);
+  return Number.isFinite(v) ? '$' + v.toFixed(4) : null;
+}
 
-  let { url, window_index: winIdx } = state;
-
-  const actualName = windowNameByIndex(winIdx);
-  if (actualName !== serverDir) {
-    const found = windowByDir(serverDir);
-    if (found == null) {
-      console.error(`Error: tmux window for ${serverDir} not found`);
-      console.error("Run 'ocmux serve' to create a new server.");
-      process.exit(1);
-    }
-    winIdx = found;
-  }
-
-  pinWindowName(winIdx);
-
-  const tuiPane = tuiPaneId(winIdx);
-  if (!tuiPane) {
-    console.error('TUI pane is dead, restarting...');
-    const count = paneCount(winIdx);
-    if (count >= 2) {
-      const panesR = tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
-      const panes = panesR.stdout.trim().split('\n').filter(Boolean);
-      const lastPane = panes[panes.length - 1];
-      const respawnR = tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
-      if (respawnR.status !== 0) {
-        tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
-      }
-    } else {
-      tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', serverDir,
-        `opencode attach --continue '${url}'`]);
-    }
+// Lay cells out in a responsive grid (row-major), collapsing columns when narrow.
+// A cell is a plain string or { label, value } (label rendered bold).
+function cellPlain(c) {
+  return (c && typeof c === 'object') ? `${c.label}: ${c.value}` : String(c);
+}
+function cellRender(c, width, labelColor = '\x1b[1m') {
+  if (c && typeof c === 'object') {
+    const label = `${c.label}:`;
+    const avail = Math.max(0, width - label.length - 1);
+    let value = String(c.value == null ? '' : c.value);
+    if (value.length > avail) value = value.slice(0, avail);
+    const plainLen = label.length + 1 + value.length;
+    return `${labelColor}${label}\x1b[0m ${value}` + ' '.repeat(Math.max(0, width - plainLen));
   }
-
-  const activeWin = activeWindowIndex();
-  if (activeWin !== winIdx) {
-    tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
+  return String(c) + ' '.repeat(Math.max(0, width - String(c).length));
+}
+function layoutCells(cells, cols, minCell = 26, labelColor = '\x1b[1m') {
+  if (!cells || cells.length === 0) return [];
+  const plains = cells.map(cellPlain);
+  let nCols = Math.max(1, Math.min(cells.length, Math.floor(Math.max(cols, 1) / minCell)));
+  const colWidths = (nc) => {
+    const w = new Array(nc).fill(0);
+    plains.forEach((p, i) => { w[i % nc] = Math.max(w[i % nc], p.length); });
+    return w;
+  };
+  let widths = colWidths(nCols);
+  while (nCols > 1 && widths.reduce((a, b) => a + b, 0) + 2 * (nCols - 1) > cols) {
+    nCols--;
+    widths = colWidths(nCols);
   }
-
-  ensureTuiZoomed(winIdx);
-  outputUrl(url, serverDir, longMode);
+  const nRows = Math.ceil(cells.length / nCols);
+  const lines = [];
+  for (let r = 0; r < nRows; r++) {
+    const parts = [];
+    for (let c = 0; c < nCols; c++) {
+      const idx = r * nCols + c;
+      if (idx >= cells.length) break;
+      parts.push(cellRender(cells[idx], widths[c], labelColor));
+    }
+    lines.push(parts.join('  ').trimEnd());
+  }
+  return lines;
 }
 
-// ---------------------------------------------------------------------------
-// Subcommand: switch — interactive session selection
-// ---------------------------------------------------------------------------
+// Bold a label and append a (truncated) value, fitting `cols`.
+function labeledLine(label, value, cols, labelColor = '\x1b[1m') {
+  const lbl = `${label}:`;
+  const avail = Math.max(0, cols - lbl.length - 1);
+  let v = String(value == null ? '' : value);
+  if (v.length > avail) v = v.slice(0, avail);
+  return `${labelColor}${lbl}\x1b[0m ${v}`;
+}
 
-function cmdSwitchMenu(longMode) {
-  const rows = listServers();
-  if (rows.length === 0) {
-    console.error('No opencode servers running.');
-    process.exit(1);
+// Info lines about the selected session: title + location (bold labels) and a
+// responsive grid. Fields are ALWAYS present (placeholders when unknown).
+// When `highlight` is true (the cursor is on the current session), labels are
+// yellow instead of white.
+function sessionInfoLines(s, runningIds, modelContext, cols, highlight = false) {
+  if (!s) return [];
+  const labelColor = highlight ? '\x1b[1;33m' : '\x1b[1m';
+  const title = (s.title && s.title.trim()) || 'Untitled';
+  const location = (s.location && s.location.directory) || 'Unknown';
+  const out = [
+    labeledLine('Title', title, cols, labelColor),
+    labeledLine('Location', location, cols, labelColor),
+  ];
+
+  const model = s.model ? `${s.model.providerID}/${s.model.id}` : null;
+  const modelLabel = model
+    ? model + (s.model.variant && s.model.variant !== 'default' ? '#' + s.model.variant : '')
+    : 'Unknown';
+  const busy = !!(runningIds && runningIds.has(s.id));
+  const since = busy
+    ? (s.time && (s.time.updated || s.time.created))
+    : (s.time && (s.time.idle || s.time.updated || s.time.created));
+  const status = `${busy ? 'BUSY' : 'IDLE'}${since ? ' ' + fmtDuration(Date.now() - since) : ' --:--:--'}`;
+
+  let tokensTxt = '--';
+  if (s.tokens) {
+    const t = s.tokens;
+    const total = (t.input || 0) + (t.output || 0) + (t.reasoning || 0);
+    tokensTxt = fmtTokens(total) || '--';
+    if (t.cache && t.cache.read) tokensTxt += ' (+' + fmtTokens(t.cache.read) + ' cache)';
   }
-  if (!process.stdin.isTTY) {
-    console.error('Error: "switch" is interactive and requires a TTY.');
-    console.error('Use "ocmux list" to list servers, or run "ocmux <dir>" to switch directly.');
-    process.exit(1);
+  const cost = fmtCost(s.cost) || '--';
+  const ctx = (model && modelContext && modelContext.get(model)) ? fmtTokens(modelContext.get(model)) : '--';
+
+  const cells = [
+    { label: 'Model', value: modelLabel },
+    { label: 'Agent', value: s.agent || 'Unknown' },
+    { label: 'Status', value: status },
+    { label: 'Tokens', value: tokensTxt },
+    { label: 'Cost', value: cost },
+    { label: 'Ctx', value: ctx },
+    { label: 'Outcome', value: s.outcome || 'Unknown' },
+  ];
+  return out.concat(layoutCells(cells, cols, 26, labelColor));
+}
+
+// Render a scrollable list into the alternate screen.
+//   heading    -> centered + bold + inverted heading
+//   row(index, item) -> string | { text, reverse }
+//   extraLines -> prompt/confirm lines right after the list (normal colors)
+//   footer     -> inverted, RIGHT-aligned key-hint bar (acts as a separator)
+//   infoLines  -> details below the footer (normal colors, bold labels)
+// A "(start-end/total)" range is appended to the heading when scrolling.
+function renderList({ title, items, cursor, row, footer, infoLines = [], extraLines = [], cols: colsArg, rows: rowsArg }) {
+  const cols = colsArg || process.stdout.columns || 80;
+  const termRows = rowsArg || process.stdout.rows || 24;
+  const extras = (extraLines || []).filter((l) => l != null && l !== '');
+  const infos = (infoLines || []).filter((l) => l != null && l !== '');
+
+  // Chrome: heading + blank, extras, footer bar, infos.
+  const reserved = 2 + extras.length + 1 + infos.length;
+  const viewHeight = Math.max(1, termRows - reserved);
+  const cursorIdx = items.length ? Math.max(0, Math.min(cursor, items.length - 1)) : 0;
+  const win = windowFor(items.length, cursorIdx, viewHeight);
+
+  let titleLine = title;
+  if (items.length > win.count) {
+    titleLine += `  (${win.start + 1}-${win.start + win.count}/${items.length})`;
   }
 
-  const cols = process.stderr.columns || 80;
-  const nameW = Math.max(...rows.map(r => path.basename(r.dir).length), 4);
-  const stsW = Math.max(...rows.map(r => r.status.length), 6);
-  const urlW = Math.max(...rows.map(r => r.url.length), 3);
-  const dirW = Math.max(...rows.map(r => r.dir.length), 9);
-  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
-  const lineWidth = Math.max(cols, nameW + 2 + stsW + 2 + urlW + 2 + dirW);
-
-  let cursor = 0;
-  let activeRow = 0;
-  let lastUrl = null;
-  let lastDir = null;
-  let exited = false;
-
-  // Query tmux for the currently active window and map it to a row. Called at
-  // init and on every draw, so the highlight always reflects tmux's real state.
-  const refreshActive = () => {
-    const idx = activeWindowIndex();
-    if (idx == null) return;
-    for (let i = 0; i < rows.length; i++) {
-      if (rows[i].index === idx) { activeRow = i; return; }
+  let out = '\x1b[2J\x1b[H';
+  out += '\x1b[1;7m' + centerIn(titleLine, cols) + '\x1b[0m\n\n';
+
+  let rendered = 0;
+  if (items.length === 0) {
+    out += '  (none)\n';
+    rendered = 1;
+  } else {
+    for (let i = 0; i < win.count; i++) {
+      const idx = win.start + i;
+      const r = row(idx, items[idx]);
+      const text = r && typeof r === 'object' ? r.text : r;
+      const reverse = r && typeof r === 'object' && r.reverse;
+      const line = `${idx === cursor ? '▶ ' : '  '}${text == null ? '' : text}`;
+      out += (reverse ? `\x1b[7m${line}\x1b[0m` : line) + '\n';
+      rendered++;
     }
-  };
+  }
+  // Pad the list area so the footer stays pinned to the bottom of the terminal
+  // (instead of floating right under the last row on a tall window).
+  for (let i = rendered; i < viewHeight; i++) out += '\n';
+  for (const l of extras) out += l + '\n';
+  const hint = footer.length > cols ? footer.slice(0, cols) : padLeft(footer, cols);
+  out += '\x1b[7m' + hint + '\x1b[0m\n';
+  for (const l of infos) out += l + '\n';
+  return out.replace(/\n$/, '');
+}
 
-  const cleanup = () => {
-    process.stderr.write('\x1b[?25h');
-    process.stderr.write('\x1b[?1049l');
-    try { process.stdin.setRawMode(false); } catch {}
-  };
+// Render an interactive session picker (alt screen). Sorted most-recently-viewed
+// first by the caller. Keys: Enter/Space switch (menu stays open), n create,
+// r rename, d delete (confirm), a annotate, p switch project, h help,
+// q/Ctrl+C quit. Input mode offers readline-style caret editing.
+// Resolves on quit (null) or with the string 'switch-project' (caller then runs
+// the project switcher and re-invokes this picker for the new project).
+function sessionMenu(sessions, currentSession, annotations, server, { onPick, onRename, onDelete, onReminder, runningIds, modelContext } = {}) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) return resolve(null);
+
+    let rows = [...sessions];
+    let current = currentSession;
+    let cursor = 0;
+    let mode = 'normal';        // 'normal' | 'help' | 'confirm' | 'input'
+    let confirmDel = null;
+    let input = null;           // { label, value, kind, caret }
+    let list = null;            // { title, items, format, onEnter }
+    let listCursor = 0;
+    let done = false;
+    const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let spinIdx = 0;
+    let spinTimer = null;
+
+    const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+    const helpLines = [
+      'Enter / Space    switch to the selected session (stays open)',
+      'n                create a new session (type a name, Enter; blank = auto)',
+      'r                rename the selected session (edit in place; ESC cancels)',
+      'R (Shift+r)      set a REMINDER for the selected session (sent in front of',
+      '                  every agentp prompt; blank clears)',
+      'd                delete the selected session (then y/N to confirm)',
+      'a                switch the AGENT of the selected session',
+      'm                switch the MODEL of the selected session',
+      'p                open the project switcher',
+      'j / k, arrows    move the cursor',
+      'h                toggle this help',
+      'q / Ctrl+C       quit',
+      '',
+      'While typing (n/r/R):',
+      '  left/right, Home/End   move the caret',
+      '  Backspace / Delete     edit in place',
+      '  Enter                  confirm, ESC cancels',
+    ];
+
+    const cleanup = () => {
+      process.stderr.write('\x1b[?25h');
+      process.stderr.write('\x1b[?1049l');
+      if (spinTimer) { clearInterval(spinTimer); spinTimer = null; }
+      process.stdout.removeListener('resize', draw);
+      try { process.stdin.setRawMode(false); } catch {}
+      process.stdin.pause();
+    };
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      process.stdin.removeAllListeners('keypress');
+      process.removeListener('SIGINT', onSig);
+      resolve(value);
+    };
+    const onSig = () => finish(null);
+    process.on('SIGINT', onSig);
+
+    const renderInputValue = (v) => {
+      const c = input.caret;
+      return v.slice(0, c) + '▏' + v.slice(c);
+    };
+
+    const draw = () => {
+      if (mode === 'help') {
+        let out = '\x1b[2J\x1b[H';
+        out += 'ocmux session picker — help\n\n';
+        for (const l of helpLines) out += '  ' + l + '\n';
+        out += '\nPress any key to return.\n';
+        process.stderr.write(out);
+        return;
+      }
+      if (mode === 'list' && list) {
+        process.stderr.write(renderList({
+          title: `ocmux — ${list.title}`,
+          items: list.items,
+          cursor: listCursor,
+          row: (i, item) => list.format(item) || '',
+          footer: 'Enter: select · ESC: back',
+        }));
+        return;
+      }
+      const cols = process.stdout.columns || 80;
+      const showTime = cols >= 48;
+      const TIME_W = 10; // dd/mm/yyyy worst case
+      const maxLen = Math.min(
+        Math.max(...rows.map(s => (s.title || s.id || '').length), 8) + 6,
+        Math.max(8, cols - (showTime ? TIME_W + 10 : 8)),
+      );
+      const extras = [];
+      if (mode === 'confirm' && confirmDel) {
+        extras.push(`Delete session "${confirmDel.title || confirmDel.id || ''}"? (y/N) `);
+      } else if (mode === 'input' && input) {
+        extras.push(`${input.label} ${renderInputValue(input.value)}`);
+      }
+      const selected = rows[cursor];
+      const selIsCurrent = !!(selected && String(selected.id) === String(current));
+      const infoLines = sessionInfoLines(selected, runningIds, modelContext, cols, selIsCurrent);
+      process.stderr.write(renderList({
+        title: 'ocmux — sessions',
+        items: rows,
+        cursor,
+        row: (i, s) => {
+          const title = (s.title || s.id || '').slice(0, maxLen);
+          const timeStr = showTime ? padLeft(fmtClock(s.time && s.time.viewed), TIME_W) + '  ' : '';
+          const mark = String(s.id) === String(current) ? ' *' : '';
+          const hasNote = annotations && annotations[s.id] ? ' ◈' : '';
+          const spin = (runningIds && runningIds.has(s.id)) ? SPINNER[spinIdx % SPINNER.length] + ' ' : '  ';
+          const text = `${spin}${timeStr}${pad(title, maxLen)}${mark}${hasNote}`;
+          // Yellow for the session currently selected in the TUI window.
+          return String(s.id) === String(current) ? `\x1b[33m${text}\x1b[0m` : text;
+        },
+        footer: 'Enter: switch · h: help · q: quit',
+        infoLines,
+        extraLines: extras,
+      }));
+    };
+
+    const startInput = (label, value, kind) => {
+      input = { label, value, kind, caret: value.length };
+      mode = 'input';
+      draw();
+    };
+
+    const applyRenameWith = (name) => {
+      const row = rows[cursor];
+      if (!row || !onRename || !name) return;
+      Promise.resolve(onRename(row, name)).then((updated) => {
+        row.title = (updated && updated.title) || name;
+        draw();
+      }).catch((err) => {
+        process.stderr.write(`\nError: ${err.message}\n`);
+        draw();
+      });
+    };
+
+    const applyReminder = (text) => {
+      const row = rows[cursor];
+      if (!row || !onReminder) return;
+      Promise.resolve(onReminder(row, text)).then((saved) => {
+        if (saved) annotations[row.id] = saved;
+        else delete annotations[row.id];
+        draw();
+      }).catch((err) => {
+        process.stderr.write(`\nError: ${err.message}\n`);
+        draw();
+      });
+    };
+
+    const applyPick = (row) => {
+      Promise.resolve(onPick ? onPick(row) : null).then((created) => {
+        if (row.new && created) {
+          rows.unshift(created);
+          current = created.id;
+          cursor = 0;
+        } else if (!row.new) {
+          current = row.id;
+        }
+        confirmDel = null;
+        draw();
+      }).catch((err) => {
+        process.stderr.write(`\nError: ${err.message}\n`);
+        confirmDel = null;
+        draw();
+      });
+    };
+
+    const applyDelete = () => {
+      const s = confirmDel;
+      if (!s || !onDelete) return;
+      Promise.resolve(onDelete(s)).then(() => {
+        rows = rows.filter(r => r.id !== s.id);
+        if (cursor >= rows.length && cursor > 0) cursor = rows.length - 1;
+        confirmDel = null;
+        mode = 'normal';
+        draw();
+      }).catch((err) => {
+        process.stderr.write(`\nError: ${err.message}\n`);
+        confirmDel = null;
+        mode = 'normal';
+        draw();
+      });
+    };
+
+    const openList = (title, items, format, onEnter) => {
+      if (!items || items.length === 0) {
+        process.stderr.write(`\nNo ${title.toLowerCase()} available.\n`);
+        draw();
+        return;
+      }
+      list = { title, items, format, onEnter };
+      listCursor = 0;
+      mode = 'list';
+      draw();
+    };
 
-  const finish = () => {
-    if (exited) return;
-    exited = true;
-    cleanup();
-    process.stdin.pause();
-    if (lastUrl) outputUrl(lastUrl, lastDir, longMode);
-    process.exit(0);
-  };
+    const commandErr = (err) => {
+      process.stderr.write(`\nError: ${err.message}\n`);
+      draw();
+    };
 
-  const draw = () => {
-    refreshActive();
-    let out = '\x1b[2J\x1b[H';
-    out += 'ocmux switch — j/k or arrows: move, Enter/Space: select (keep switching), q/Ctrl+C: quit\n\n';
-    for (let i = 0; i < rows.length; i++) {
-      const row = rows[i];
-      const marker = i === cursor ? '▶ ' : '  ';
-      const line = `${marker}${pad(path.basename(row.dir), nameW)}  ${pad(row.status, stsW)}  ${pad(row.url, urlW)}  ${pad(row.dir, dirW)}`;
-      if (i === activeRow) {
-        out += '\x1b[7m' + pad(line, lineWidth) + '\x1b[0m\n';
-      } else {
-        out += line + '\n';
+    process.stdin.on('keypress', (str, key) => {
+      if (mode === 'help') {
+        mode = 'normal';
+        draw();
+        return;
       }
-    }
-    process.stderr.write(out);
-  };
+      if (mode === 'confirm') {
+        if (key.name === 'y') return applyDelete();
+        if (key.name === 'n' || key.name === 'escape' || key.name === 'q' || key.name === 'return') {
+          confirmDel = null;
+          mode = 'normal';
+          draw();
+        }
+        return;
+      }
+      if (mode === 'input') {
+        if (key.name === 'escape') {
+          input = null;
+          mode = 'normal';
+          draw();
+        } else if (key.name === 'return' || key.name === 'enter') {
+          const v = input.value;
+          const kind = input.kind;
+          input = null;
+          mode = 'normal';
+          draw();
+          if (kind === 'create') {
+            applyPick({ new: true, name: v.trim() });
+          } else if (kind === 'reminder') {
+            applyReminder(v.trim());
+          } else if (v.trim()) {
+            applyRenameWith(v.trim());
+          }
+        } else if (key.name === 'backspace') {
+          if (input.caret > 0) {
+            input.value = input.value.slice(0, input.caret - 1) + input.value.slice(input.caret);
+            input.caret--;
+          }
+          draw();
+        } else if (key.name === 'delete' || key.name === 'del') {
+          if (input.caret < input.value.length) {
+            input.value = input.value.slice(0, input.caret) + input.value.slice(input.caret + 1);
+          }
+          draw();
+        } else if (key.name === 'left' || str === '\u001b[D') {
+          input.caret = Math.max(0, input.caret - 1);
+          draw();
+        } else if (key.name === 'right' || str === '\u001b[C') {
+          input.caret = Math.min(input.value.length, input.caret + 1);
+          draw();
+        } else if (key.name === 'home') {
+          input.caret = 0;
+          draw();
+        } else if (key.name === 'end') {
+          input.caret = input.value.length;
+          draw();
+        } else if (str && !key.ctrl && !key.meta && str >= ' ') {
+          input.value = input.value.slice(0, input.caret) + str + input.value.slice(input.caret);
+          input.caret++;
+          draw();
+        }
+        return;
+      }
+      if (mode === 'list') {
+        if (key.name === 'escape' || key.name === 'q' || key.name === 'backspace') {
+          list = null;
+          mode = 'normal';
+          draw();
+        } else if (key.name === 'up' || str === 'k') {
+          listCursor = (listCursor - 1 + list.items.length) % list.items.length;
+          draw();
+        } else if (key.name === 'down' || str === 'j') {
+          listCursor = (listCursor + 1) % list.items.length;
+          draw();
+        } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+          const item = list.items[listCursor];
+          const onEnter = list.onEnter;
+          list = null;
+          mode = 'normal';
+          draw();
+          Promise.resolve(onEnter(item)).then(() => draw()).catch(commandErr);
+        }
+        return;
+      }
+      if (key.ctrl && key.name === 'c') return finish(null);
+      if (key.name === 'q') return finish(null);
+      if (key.name === 'p') return finish('switch-project');
+      if (key.name === 'h') {
+        mode = 'help';
+        draw();
+        return;
+      }
+      if (key.name === 'n') {
+        startInput('New session name (blank for auto; ESC cancels):', '', 'create');
+        return;
+      }
+      // Shift+r → Reminder; lowercase r → Rename.
+      if (str === 'R') {
+        const row = rows[cursor];
+        const note = (row && annotations && annotations[row.id]) || '';
+        startInput('Reminder for this session (blank clears; ESC cancels):', note, 'reminder');
+        return;
+      }
+      if (key.name === 'r' && cursor < rows.length) {
+        startInput('Rename to (ESC cancels):', rows[cursor].title || '', 'rename');
+        return;
+      }
+      if (key.name === 'a') {
+        const target = rows[cursor];
+        if (target) {
+          listAgents(server).then((all) => {
+            const primary = all.filter(x => x.mode === 'primary' && !x.hidden);
+            const agents = primary.length ? primary : all;
+            openList('Agents', agents, (x) => `${x.name || x.id}${x.description ? ' — ' + x.description.slice(0, 40) : ''}`, (item) =>
+              updateSession(server, target.id, null, item.id));
+          }).catch(commandErr);
+        }
+        return;
+      }
+      if (key.name === 'm') {
+        const target = rows[cursor];
+        if (target) {
+          listModels(server).then((models) => {
+            openList('Models', models, (x) => `${x.label}${x.variant ? `#${x.variant}` : ''}`, (item) =>
+              switchModel(server, target.id, item));
+          }).catch(commandErr);
+        }
+        return;
+      }
+      if (key.name === 'd') {
+        if (cursor < rows.length) {
+          confirmDel = rows[cursor];
+          mode = 'confirm';
+          draw();
+        }
+        return;
+      }
+      if (rows.length > 0 && (key.name === 'up' || str === 'k')) {
+        cursor = (cursor - 1 + rows.length) % rows.length;
+        draw();
+      } else if (rows.length > 0 && (key.name === 'down' || str === 'j')) {
+        cursor = (cursor + 1) % rows.length;
+        draw();
+      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+        if (cursor < rows.length) applyPick(rows[cursor]);
+      }
+    });
 
-  const activate = (i) => {
-    const row = rows[i];
-    try {
-      activateServer(row.dir, row.index, row.url);
-      lastUrl = row.url;
-      lastDir = row.dir;
-    } catch (err) {
-      process.stderr.write(`\nError: ${err.message}\n`);
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.on('resize', draw);
+    // Animate the spinner while any listed session is running.
+    if (rows.some(s => runningIds && runningIds.has(s.id))) {
+      spinTimer = setInterval(() => { spinIdx++; draw(); }, 120);
     }
+    process.stderr.write('\x1b[?1049h\x1b[?25l');
     draw();
-  };
+  });
+}
 
-  process.stdin.on('keypress', (str, key) => {
-    if (key.ctrl && key.name === 'c') return finish();
-    if (key.name === 'q') return finish();
-    if (key.name === 'up' || str === 'k') {
-      cursor = (cursor + rows.length - 1) % rows.length;
-      draw();
-    } else if (key.name === 'down' || str === 'j') {
-      cursor = (cursor + 1) % rows.length;
-      draw();
-    } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
-      activate(cursor);
+// Interactive project picker — purely visual/navigation, never writes state.
+function switchMenu(rows, longMode) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      console.error('Error: "switch" is interactive and requires a TTY.');
+      process.exit(1);
+    }
+    if (rows.length === 0) {
+      console.log('No opencode projects running.');
+      resolve(null);
+      return;
     }
-  });
 
-  process.on('SIGINT', finish);
-  process.on('SIGTERM', finish);
+    const nameW = Math.max(...rows.map(r => path.basename(r.dir).length), 4);
+    const stsW = Math.max(...rows.map(r => r.status.length), 6);
+    const ssnW = Math.max(...rows.map(r => (r.session || '').length), 7);
+    const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+    const cols = process.stderr.columns || 80;
+    const lineWidth = Math.max(cols, nameW + 2 + stsW + 2 + ssnW + 6);
+
+    let cursor = 0;
+    let activeRow = 0;
+    let lastDir = null;
+    let done = false;
+
+    const refreshActive = () => {
+      const idx = activeWindowIndex();
+      if (idx == null) return;
+      for (let i = 0; i < rows.length; i++) {
+        if (rows[i].index === idx) { activeRow = i; return; }
+      }
+    };
+
+    const cleanup = () => {
+      process.stderr.write('\x1b[?25h');
+      process.stderr.write('\x1b[?1049l');
+      process.stdout.removeListener('resize', draw);
+      try { process.stdin.setRawMode(false); } catch {}
+    };
+
+    const finish = () => {
+      if (done) return;
+      done = true;
+      cleanup();
+      process.stdin.pause();
+      resolve(lastDir);
+    };
+
+    const draw = () => {
+      refreshActive();
+      process.stderr.write(renderList({
+        title: 'ocmux — project switcher',
+        items: rows,
+        cursor,
+        row: (i, row) => {
+          const session = row.session ? row.session.slice(0, 14) : '(none)';
+          const text = `${pad(path.basename(row.dir), nameW)}  ${pad(row.status, stsW)}  ${pad(session, ssnW)}  ${row.dir}`;
+          return i === activeRow ? { text, reverse: true } : text;
+        },
+        footer: 'Enter: focus · q: quit',
+      }));
+    };
+
+    const activate = (i) => {
+      const row = rows[i];
+      try {
+        if (row.server) {
+          activateProject(row.dir, row.index, row.server, row.session);
+        } else {
+          tmux(['select-window', '-t', `${SESSION}:${row.index}`]);
+        }
+        lastDir = row.dir;
+      } catch (err) {
+        process.stderr.write(`\nError: ${err.message}\n`);
+      }
+      draw();
+    };
+
+    const onSig = () => finish();
+    process.on('SIGINT', onSig);
+
+    process.stdin.on('keypress', (str, key) => {
+      if (key.ctrl && key.name === 'c') return finish();
+      if (key.name === 'q') return finish();
+      if (key.name === 'up' || str === 'k') {
+        cursor = (cursor + rows.length - 1) % rows.length;
+        draw();
+      } else if (key.name === 'down' || str === 'j') {
+        cursor = (cursor + 1) % rows.length;
+        draw();
+      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+        activate(cursor);
+      }
+    });
 
-  readline.emitKeypressEvents(process.stdin);
-  process.stdin.setRawMode(true);
-  process.stdin.resume();
-  process.stderr.write('\x1b[?1049h\x1b[?25l');
-  refreshActive();
-  cursor = activeRow;
-  draw();
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.on('resize', draw);
+    process.stderr.write('\x1b[?1049h\x1b[?25l');
+    draw();
+  });
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: list
+// Subcommand: default — interactive session switcher for the current project
 // ---------------------------------------------------------------------------
 
-function cmdList() {
-  const rows = listServers();
-  if (rows.length === 0) {
-    console.log('No opencode servers running.');
-    return;
-  }
+async function cmdSessionSwitch(targetDir, directRef) {
+  let target = targetDir;
+  for (;;) {
+    const sf = findParentStatefile(target);
+    if (!sf) {
+      console.error(`Error: no .ocmux.json found in ${target} or any of its parents.`);
+      console.error(`Run 'ocmux serve' to create a project window.`);
+      process.exit(1);
+    }
+    const state = projectState.readProjectState(sf);
+    const server = state.server;
+    if (!server) {
+      console.error(`Error: ${sf} does not record a server.`);
+      console.error(`Run 'ocmux serve --server <url>' to set it up, or add "server" to the file.`);
+      process.exit(1);
+    }
+    const dir = state.directory;
 
-  const urlW = Math.max(...rows.map(r => r.url.length), 3);
-  const dirW = Math.max(...rows.map(r => r.dir.length), 9);
-  const stsW = Math.max(...rows.map(r => r.status.length), 6);
+    const alive = await checkServer(server);
+    if (!alive) {
+      console.error(`Error: OpenCode server not reachable at ${server}.`);
+      console.error(`Start it with 'opencode serve' (or your usual launcher) first.`);
+      process.exit(1);
+    }
 
-  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+    const winIdx = windowByDir(dir);
+    if (winIdx == null) {
+      console.error(`Error: no tmux window for ${dir}.`);
+      console.error(`Run 'ocmux serve' to create it.`);
+      process.exit(1);
+    }
 
-  console.log(`${pad('URL', urlW)}  ${pad('Directory', dirW)}  ${pad('Status', stsW)}`);
-  for (const row of rows) {
-    console.log(`${pad(row.url, urlW)}  ${pad(row.dir, dirW)}  ${pad(row.status, stsW)}`);
+    // Focus this project's window up-front so the picker (and any session
+    // switch) never leaves another project's window selected.
+    activateProject(dir, winIdx, server, state.session);
+
+    const sessions = await listSessions(server, dir).catch((err) => {
+      console.error(`Error connecting to ${server}: ${err.message}`);
+      process.exit(1);
+    });
+    const sorted = sortSessionsByRecency(sessions);
+    const annotations = projectState.readAnnotations(sf);
+    const runningIds = await getActiveSessions(server);
+    let modelContext = new Map();
+    try {
+      const models = await listModels(server);
+      modelContext = new Map(models.filter(m => m.context).map(m => [`${m.providerID}/${m.id}`, m.context]));
+    } catch { /* context limits unavailable */ }
+
+    const applySession = (id) => {
+      projectState.writeProjectState(sf, { session: id });
+      relaunchTui(winIdx, dir, server, id);
+    };
+
+    if (directRef) {
+      const pick = sorted.find(s => String(s.id) === directRef)
+        || sorted.find(s => (s.title || '').toLowerCase() === directRef.toLowerCase())
+        || null;
+      if (!pick) {
+        console.error(`Error: no session matching "${directRef}" in ${dir}.`);
+        process.exit(1);
+      }
+      applySession(pick.id);
+      return;
+    }
+
+    if (!process.stdin.isTTY) {
+      // Silent path (non-TTY): just make sure the window is focused.
+      activateProject(dir, winIdx, server, state.session);
+      return;
+    }
+
+    // Interactive: Enter switches but stays open; n creates (inheriting the
+    // model of the previously selected session); r renames; R sets a reminder;
+    // d deletes; a switches agent; m switches model; p switches project; q quits.
+    let lastRef = (state.session && sorted.find(s => String(s.id) === String(state.session))) || sorted[0] || null;
+    const result = await new Promise((resolve) => {
+      sessionMenu(sorted, state.session, annotations, server, {
+        runningIds,
+        modelContext,
+        onPick: async (row) => {
+          if (row.new) {
+            const created = await createSessionWithModel(server, row.name || undefined, dir, [lastRef, ...sorted]).catch((err) => {
+              console.error(`Error creating session: ${err.message}`);
+              return null;
+            });
+            if (created) applySession(created.id);
+            return created || null;
+          }
+          lastRef = row;
+          applySession(row.id);
+        },
+        onRename: async (row, name) => {
+          const updated = await updateSession(server, row.id, name).catch((err) => {
+            console.error(`Error renaming session: ${err.message}`);
+            throw err;
+          });
+          return updated;
+        },
+        onDelete: async (row) => {
+          await deleteSession(server, row.id).catch((err) => {
+            console.error(`Error deleting session: ${err.message}`);
+            throw err;
+          });
+          if (String(row.id) === String(state.session)) {
+            projectState.writeProjectState(sf, { session: null });
+          }
+        },
+        onReminder: async (row, text) => {
+          try {
+            return projectState.writeAnnotation(sf, row.id, text);
+          } catch (err) {
+            console.error(`Error saving reminder: ${err.message}`);
+            throw err;
+          }
+        },
+      }).then(resolve);
+    });
+
+    if (result === 'switch-project') {
+      // 'p' pressed: open the project switcher, then re-run this picker for
+      // the project that was just activated (if any).
+      ensureSession();
+      const lastDir = await switchMenu(listProjects());
+      if (!lastDir) break;
+      target = lastDir;
+      continue;
+    }
+    break;
   }
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: new
+// Subcommand: serve — create a project TUI window (server is user-managed)
 // ---------------------------------------------------------------------------
 
-function cmdNew(targetDir, longMode, printLogs) {
+async function cmdServeNew(targetDir, serverArg, force) {
+  try { targetDir = fs.realpathSync(targetDir); } catch {}
+
   const sf = path.join(targetDir, '.ocmux.json');
   if (fs.existsSync(sf)) {
-    console.error(`Error: a server already exists in ${targetDir}.`);
-    console.error("Run 'ocmux' without arguments to switch to it, or 'ocmux kill' to stop it first.");
-    process.exit(1);
+    if (!force) {
+      console.error(`Error: a project window already exists in ${targetDir}.`);
+      console.error(`Use 'ocmux' to switch sessions there, or 'ocmux serve --server <url> --force' to repoint it.`);
+      process.exit(1);
+    }
+    return doForceServe(targetDir, sf, serverArg || DEFAULT_SERVER);
   }
 
   const parent = findParentStatefile(path.dirname(targetDir));
   if (parent) {
     const parentDir = path.dirname(parent);
-    console.error(`Warning: there is already an opencode server in ${parentDir}.`);
-    console.error("Running 'ocmux' without arguments would switch to that server.");
+    console.error(`Warning: there is already an opencode project in ${parentDir}.`);
+    console.error(`Run 'ocmux' and press 'p' to move between project windows.`);
 
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    rl.question('Are you sure you want to create a new server here? [y/N] ', (answer) => {
+    rl.question('Are you sure you want to create a new project window here? [y/N] ', (answer) => {
       rl.close();
       if (!/^[yY]([eE][sS])?$/.test(answer.trim())) {
         console.error('Cancelled.');
         process.exit(0);
       }
-      doNew(targetDir, longMode, printLogs);
+      doServeNew(targetDir, serverArg).catch((err) => {
+        console.error(err ? err.message : String(err));
+        process.exit(1);
+      });
     });
-  } else {
-    doNew(targetDir, longMode, printLogs);
+    return;
   }
+  return doServeNew(targetDir, serverArg);
 }
 
-function doNew(targetDir, longMode, printLogs) {
-  // Normalize to real path so tmux window names are consistent regardless of symlinks
-  try { targetDir = fs.realpathSync(targetDir); } catch {}
-  ensureSession();
-  const lf = logfileFor(targetDir);
-
-  console.error(`Starting opencode server for ${targetDir}...`);
-
-  // Create window with interactive shell so .bashrc/.zshrc is sourced
-  const rc = tmux(['new-window', '-d', '-t', SESSION, '-n', targetDir, '-c', targetDir]);
-  if (rc.status !== 0) {
-    console.error(`Error: failed to create tmux window: ${rc.stderr}`);
+// Repoint an existing project to a (possibly new) server: update .ocmux.json's
+// `server`, keep the session if it still exists, and (re)launch the TUI on it.
+async function doForceServe(targetDir, sf, server) {
+  const alive = await checkServer(server);
+  if (!alive) {
+    console.error(`Error: OpenCode server not reachable at ${server}.`);
+    console.error(`Start it with 'opencode serve' (or pass --server <url>).`);
     process.exit(1);
   }
-
-  const winIdx = windowByDir(targetDir);
-  if (winIdx == null) {
-    console.error('Error: window was not created properly');
+  const state = projectState.readProjectState(sf);
+  const sessions = await listSessions(server, targetDir).catch((err) => {
+    console.error(`Error connecting to ${server}: ${err.message}`);
     process.exit(1);
+  });
+  let session = (state && state.session && sessions.some(s => String(s.id) === String(state.session)))
+    ? state.session
+    : newestSessionId(sessions);
+  if (!session) {
+    const created = await createSessionWithModel(server, undefined, targetDir, sessions);
+    session = created.id;
   }
+  projectState.writeProjectState(sf, { server, session });
+  const winIdx = windowByDir(targetDir);
+  if (winIdx != null) {
+    relaunchTui(winIdx, targetDir, server, session);
+    console.error(`Repointed ${targetDir} to ${server} (session ${session}).`);
+  } else {
+    createProjectWindow(targetDir, server, session);
+    console.error(`Recreated project window for ${targetDir} → ${server} (session ${session}).`);
+  }
+}
 
-  pinWindowName(winIdx);
-
-  // Truncate log file so stale URL from previous run can't be matched by polling
-  try { fs.truncateSync(lf); } catch { /* may not exist yet */ }
-
-  // Send the command to the interactive shell (like typing it manually)
-  const serveFlags = printLogs ? '--print-logs' : '';
-  tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
-    `opencode serve ${serveFlags} 2>&1 | tee '${lf}'`, 'Enter']);
+async function doServeNew(targetDir, serverArg) {
+  const server = serverArg || DEFAULT_SERVER;
 
-  // Wait up to 10s for the URL in the logfile.
-  // Don't break on first match — keep polling so url ends up holding the
-  // final URL in case the server prints multiple URLs during startup.
-  let url = null;
-  for (let i = 0; i < 50; i++) {
-    sleep(0.2);
-    const log = (() => { try { return fs.readFileSync(lf, 'utf8'); } catch { return ''; } })();
-    const m = log.match(URL_RE);
-    if (m) url = m[1];
+  const alive = await checkServer(server);
+  if (!alive) {
+    console.error(`Error: OpenCode server not reachable at ${server}.`);
+    console.error(`Start it with 'opencode serve' (or --server <url> to point elsewhere).`);
+    process.exit(1);
   }
 
-  if (!url) {
-    console.error('Error: opencode server did not start within 10 seconds');
-    const wi = windowByDir(targetDir);
-    if (wi != null) tmux(['kill-window', '-t', `${SESSION}:${wi}`]);
+  // Pick the newest session already in this directory, or create one.
+  let sessions = [];
+  try {
+    sessions = await listSessions(server, targetDir);
+  } catch (err) {
+    console.error(`Error connecting to ${server}: ${err.message}`);
     process.exit(1);
   }
-
-  const state = { url, logfile: lf, window_index: winIdx };
-  fs.writeFileSync(path.join(targetDir, '.ocmux.json'), JSON.stringify(state) + '\n');
-
-  const splitResult = tmux(['split-window', '-v', '-P', '-F', '#{pane_id}', '-t', `${SESSION}:${winIdx}`, '-c', targetDir]);
-  const tuiPane = splitResult.stdout.trim();
-  sleep(0.2);
-  tmux(['send-keys', '-t', tuiPane,
-    `opencode attach --continue '${url}'`, 'Enter']);
-  sleep(0.5);
-  if (tuiPane) tmux(['resize-pane', '-Z', '-t', tuiPane]);
-
-  const activeWin = activeWindowIndex();
-  if (activeWin !== winIdx) {
-    tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
+  let session = newestSessionId(sessions);
+  if (!session) {
+    try {
+      const created = await createSessionWithModel(server, undefined, targetDir, sessions);
+      session = created.id;
+    } catch (err) {
+      console.error(`Error creating session: ${err.message}`);
+      process.exit(1);
+    }
   }
 
-  outputUrl(url, targetDir, longMode);
+  console.error(`Creating project window for ${targetDir} (session ${session})...`);
+  try {
+    createProjectWindow(targetDir, server, session);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: kill
+// Subcommand: list
 // ---------------------------------------------------------------------------
 
-function cmdKill(statefile) {
-  const serverDir = path.dirname(statefile);
-  const state = readState(statefile);
-
-  if (!state || !state.url || state.window_index == null) {
-    console.error(`Error: invalid state file ${statefile}`);
-    process.exit(1);
+function cmdList(longMode) {
+  const rows = listProjects();
+  if (rows.length === 0) {
+    console.log('No opencode projects running.');
+    return;
   }
 
-  let { window_index: winIdx } = state;
+  const dirW = Math.max(...rows.map(r => r.dir.length), 9);
+  const stsW = Math.max(...rows.map(r => r.status.length), 6);
+  const ssnW = Math.max(...rows.map(r => (r.session || '').length), 7);
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
 
-  console.error(`Stopping server and removing window for ${serverDir}...`);
+  console.log(`${pad('Directory', dirW)}  ${pad('Status', stsW)}  ${pad('Session', ssnW)}`);
+  for (const row of rows) {
+    console.log(`${pad(row.dir, dirW)}  ${pad(row.status, stsW)}  ${pad(row.session || '(none)', ssnW)}`);
+    if (longMode && row.server) console.log(`    server: ${row.server}`);
+  }
+}
 
-  const sessionR = tmux(['has-session', '-t', SESSION]);
-  if (sessionR.status === 0) {
-    const actualName = windowNameByIndex(winIdx);
-    if (actualName !== serverDir) {
-      const found = windowByDir(serverDir);
-      if (found != null) winIdx = found;
-    }
+// ---------------------------------------------------------------------------
+// Subcommand: kill — close the project window but keep .ocmux.json
+// ---------------------------------------------------------------------------
 
-    if (winIdx != null) {
-      tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
-      tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, 'C-c']);
-      sleep(0.3);
-      tmux(['kill-window', '-t', `${SESSION}:${winIdx}`]);
-      console.error('Window removed.');
-    } else {
-      console.error(`Tmux window not found for ${serverDir} (cleaning up state file).`);
+function cmdKill(targetDir) {
+  const sf = findParentStatefile(targetDir);
+  if (!sf) {
+    console.error(`Error: no .ocmux.json found in ${targetDir} or any of its parents.`);
+    process.exit(1);
+  }
+  const serverDir = path.dirname(sf);
+  const winIdx = windowByDir(serverDir);
+  if (winIdx != null) {
+    console.error(`Closing project window for ${serverDir}...`);
+    try {
+      closeProjectWindow(winIdx);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   } else {
-    console.error("No tmux session '" + SESSION + "' found (cleaning up state file).");
+    console.error(`Tmux window not found for ${serverDir} (state kept).`);
   }
-
-  fs.unlinkSync(statefile);
-  console.error('Done.');
+  // Session memory intentionally kept.
+  projectState.writeProjectState(sf, { status: 'stopped' });
+  console.error('Done (state file kept).');
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: resurrect — kill dead server and create a fresh one
+// Subcommand: resurrect — recreate a project window from its state
 // ---------------------------------------------------------------------------
 
-function cmdResurrect(targetDir, longMode, printLogs) {
+async function cmdResurrect(targetDir) {
   const sf = findParentStatefile(targetDir);
   if (!sf) {
     console.error(`Error: no .ocmux.json found in ${targetDir} or any of its parents.`);
-    console.error("Run 'ocmux serve' to create a new server.");
     process.exit(1);
   }
+  const state = projectState.readProjectState(sf);
+  const server = state.server;
+  if (!server) {
+    console.error(`Error: ${sf} does not record a server.`);
+    process.exit(1);
+  }
+  const dir = state.directory;
 
-  const serverDir = path.dirname(sf);
-  console.error(`Resurrecting server for ${serverDir}...`);
+  const winIdx = windowByDir(dir);
+  if (winIdx != null) {
+    console.error(`Project window for ${dir} already exists.`);
+    return;
+  }
 
-  try {
-    const { url } = resurrectServer(serverDir, printLogs);
-    outputUrl(url, serverDir, longMode);
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
+  const alive = await checkServer(server);
+  if (!alive) {
+    console.error(`Error: OpenCode server not reachable at ${server}.`);
     process.exit(1);
   }
+  console.error(`Recreating project window for ${dir}...`);
+  createProjectWindow(dir, server, state.session);
+}
+
+// ---------------------------------------------------------------------------
+// Subcommand: migrate — rewrite legacy .ocmux.json files to v2
+// ---------------------------------------------------------------------------
+
+function cmdMigrate() {
+  const rows = listProjects();
+  let migrated = 0;
+  for (const row of rows) {
+    const sf = statefileFor(row.dir);
+    const state = projectState.readProjectState(sf);
+    if (!state) continue;
+    if (state.version >= 2) continue;
+    projectState.writeProjectState(sf, {
+      directory: row.dir,
+      server: state.server,
+      session: state.session,
+    });
+    migrated++;
+    console.error(`Migrated ${sf}`);
+  }
+  if (migrated === 0) console.error('No legacy state files found.');
 }
 
 // ---------------------------------------------------------------------------
-// Argument parsing
+// ---------------------------------------------------------------------------
+// Help
+// ---------------------------------------------------------------------------
+
+function printHelp() {
+  console.error(`Usage: ${SCRIPT} [-l] [<subcommand>] [<directory>]`);
+  console.error('');
+  console.error('Manage project OpenCode TUI windows in tmux. The OpenCode server');
+  console.error('itself is user-managed: start it once with `opencode serve`.');
+  console.error('');
+  console.error('Without arguments, searches upward from <directory> (default: $PWD)');
+  console.error('for .ocmux.json and opens an interactive SESSION picker for that');
+  console.error('project (requires a TTY). In the picker:');
+  console.error('  Enter switch · n new · r rename · R remind · d delete · a agents · m model');
+  console.error('  p projects · h help · q quit');
+  console.error('Selecting updates .ocmux.json and relaunches the project TUI on the');
+  console.error('chosen session. Silent on success. (p opens the read-only project');
+  console.error('switcher; it never modifies .ocmux.json.)');
+  console.error('');
+  console.error('Subcommands:');
+  console.error('  serve     Create a TUI window for <directory> (default: $PWD).');
+  console.error('            --server <url>  Server to record (default: $OCMUX_SERVER or http://localhost:4096).');
+  console.error('            --force         Repoint an existing project to --server (overwrites .ocmux.json).');
+  console.error('            --git / --GIT   Use the nearest parent with a .git entry / directory.');
+  console.error('            Aliased as "new" for backwards compatibility.');
+  console.error('  session <id|title>');
+  console.error('            Non-interactive session switch for the current project.');
+  console.error('  list [-l] List project windows (with -l, their server URL).');
+  console.error('  kill      Close the current project window. KEEPS .ocmux.json (session memory).');
+  console.error('  resurrect Recreate the project window from its .ocmux.json.');
+  console.error('  migrate   Rewrite legacy .ocmux.json files to the v2 schema.');
+  console.error('');
+  console.error('Reminders: the R key in the session picker attaches a note to a');
+  console.error('session; agentp prepends it to every prompt sent to that session.');
+  console.error('');
+  console.error('Options:');
+  console.error('  -l          Long output (list: also show server URL).');
+  console.error('  --version   Show version');
+  console.error('  -h          Show this help');
+  console.error('');
+  console.error('See also: agentp -- pipe prompts into OpenCode from stdin');
+  console.error('          tgagentp -- Telegram bridge for OpenCode (tgagentp --help)');
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------------------
+// Argument parsing + dispatch
 // ---------------------------------------------------------------------------
 
 function main() {
   let longMode = false;
   let gitMode = null;
-  let printLogs = false;
-  let lastMode = false;
+  let serverArg = null;
+  let force = false;
   const positional = [];
   let dirIsForced = false;
 
-  for (const arg of process.argv.slice(2)) {
+  const parsedArgs = process.argv.slice(2);
+  for (let i = 0; i < parsedArgs.length; i++) {
+    const arg = parsedArgs[i];
     if (arg === '-l') {
       longMode = true;
-    } else if (arg === '--last') {
-      lastMode = true;
-    } else if (arg === '--print-logs') {
-      printLogs = true;
+    } else if (arg === '--server') {
+      const val = parsedArgs[i + 1];
+      if (!val || val.startsWith('-')) {
+        console.error("Error: '--server' requires a URL argument.");
+        process.exit(1);
+      }
+      serverArg = val;
+      i++;
+    } else if (arg === 'switch' || arg === 'model') {
+      console.error(`Error: the '${arg}' subcommand was removed.`);
+      console.error(`Press '${arg === 'switch' ? 'p' : 'm'}' inside the session picker (ocmux) for that action.`);
+      process.exit(1);
+    } else if (arg === '--force') {
+      force = true;
     } else if (arg === '--git') {
       if (gitMode && gitMode !== 'nearest') {
         console.error("Error: cannot combine '--git' with '--GIT'.");
@@ -595,22 +1289,19 @@ function main() {
     } else if (arg === '--') {
       dirIsForced = true;
     } else if (arg.startsWith('-')) {
-      if (arg === '--new') {
-        console.error("Error: '--new' is no longer a flag. Use 'ocmux serve' instead.");
-      } else if (arg === '--kill') {
-        console.error("Error: '--kill' is no longer a flag. Use 'ocmux kill' instead.");
-      } else {
-        console.error(`Error: unknown option '${arg}'`);
-        console.error(`Run '${SCRIPT} -h' for help.`);
-      }
+      console.error(`Error: unknown option '${arg}'`);
+      console.error(`Run '${SCRIPT} -h' for help.`);
       process.exit(1);
     } else {
       positional.push(arg);
     }
   }
 
+  // Handle --server <url> (inline-consumed in the loop above; nothing here).
+
   let subcommand = null;
   let targetDir = null;
+  let directRef = null;
 
   for (const arg of positional) {
     if (dirIsForced) {
@@ -620,12 +1311,16 @@ function main() {
         process.exit(1);
       }
       targetDir = resolveDir(arg);
-    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list' || arg === 'resurrect' || arg === 'switch') {
+    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list'
+      || arg === 'resurrect' || arg === 'session'
+      || arg === 'migrate') {
       if (subcommand) {
         console.error(`Error: multiple subcommands specified: '${subcommand}' and '${arg}'`);
         process.exit(1);
       }
       subcommand = arg;
+    } else if (subcommand === 'session' && directRef === null) {
+      directRef = arg;
     } else {
       if (targetDir) {
         console.error(`Error: unexpected argument '${arg}'`);
@@ -637,128 +1332,68 @@ function main() {
 
   if (!targetDir) targetDir = process.cwd();
 
-  // Dispatch
-  if (lastMode) {
-    if (gitMode) {
-      console.error("Error: '--last' cannot be combined with '--git' or '--GIT'.");
-      process.exit(1);
-    }
-    if (printLogs) {
-      console.error("Error: '--last' cannot be combined with '--print-logs'.");
-      process.exit(1);
-    }
-    if (subcommand) {
-      console.error(`Error: '--last' cannot be combined with subcommand '${subcommand}'.`);
-      process.exit(1);
-    }
-    if (targetDir !== process.cwd()) {
-      console.error("Error: '--last' does not accept a directory path.");
-      process.exit(1);
-    }
-    ensureSession();
-    const url = getActiveServer();
-    if (!url) {
-      console.error('Error: no active opencode server found in tmux.');
-      console.error("Run 'ocmux serve' to create a server, or switch to an existing one.");
-      process.exit(1);
-    }
-    outputUrl(url, null, longMode);
-    return;
-  }
+  // Dispatch. Each branch may throw synchronously (EXIT) for validation errors
+  // or return a promise for async commands; main() returns the settled promise
+  // so tests can await it.
+  let p = Promise.resolve();
 
   if (subcommand === 'list') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    if (printLogs) {
-      console.error("Error: '--print-logs' is only valid with 'serve'.");
-      process.exit(1);
-    }
     if (targetDir !== process.cwd()) {
       console.error("Error: 'list' does not accept a directory path.");
       process.exit(1);
     }
-    cmdList();
-  } else if (subcommand === 'switch') {
+    ensureSession();
+    cmdList(longMode);
+  } else if (subcommand === 'session') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    if (printLogs) {
-      console.error("Error: '--print-logs' is only valid with 'serve'.");
-      process.exit(1);
-    }
-    if (targetDir !== process.cwd()) {
-      console.error("Error: 'switch' does not accept a directory path.");
-      process.exit(1);
-    }
-    ensureSession();
-    cmdSwitchMenu(longMode);
+    p = cmdSessionSwitch(targetDir, directRef);
   } else if (subcommand === 'kill') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    if (printLogs) {
-      console.error("Error: '--print-logs' is only valid with 'serve'.");
-      process.exit(1);
-    }
-    const sf = findParentStatefile(targetDir);
-    if (!sf) {
-      console.error(`Error: no opencode server found in ${targetDir} or any of its parents.`);
-      console.error("Run 'ocmux serve' to create a new server.");
-      process.exit(1);
-    }
-    cmdKill(sf);
+    cmdKill(targetDir);
   } else if (subcommand === 'resurrect') {
-    if (gitMode) {
-      console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
+    p = cmdResurrect(targetDir);
+  } else if (subcommand === 'migrate') {
+    if (targetDir !== process.cwd()) {
+      console.error("Error: 'migrate' does not accept a directory path.");
       process.exit(1);
     }
-    cmdResurrect(targetDir, longMode, printLogs);
+    cmdMigrate();
   } else if (subcommand === 'serve' || subcommand === 'new') {
     if (gitMode) {
       const flagLabel = gitMode === 'root' ? '--GIT' : '--git';
       targetDir = resolveGitDir(targetDir, gitMode === 'root', flagLabel);
     }
-    cmdNew(targetDir, longMode, printLogs);
+    p = cmdServeNew(targetDir, serverArg, force);
   } else {
+    // Default: session switcher for the current project.
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    if (printLogs) {
-      console.error("Error: '--print-logs' is only valid with 'serve'.");
-      process.exit(1);
-    }
-    // Default mode — find an existing server and switch to it
-    let sf = findParentStatefile(targetDir);
-    if (!sf) {
-      console.log(`Error: no opencode server found in ${targetDir} or any of its parents.`);
-      console.error("Run 'ocmux serve' to create a new server.");
-      process.exit(1);
-    }
-
-    // Skip stale state files whose tmux window no longer exists,
-    // and search from the parent directory instead.
-    const state = readState(sf);
-    if (state && state.window_index != null) {
-      const serverDir = path.dirname(sf);
-      const actualName = windowNameByIndex(state.window_index);
-      if (actualName !== serverDir && windowByDir(serverDir) == null) {
-        const parentSf = findParentStatefile(path.dirname(serverDir));
-        if (parentSf) sf = parentSf;
-      }
-    }
-
-    ensureSession();
-    cmdSwitch(sf, longMode);
+    p = cmdSessionSwitch(targetDir, null);
   }
+
+  return p.catch((err) => {
+    // Already exiting (a command called process.exit — the test stub throws
+    // EXIT:code). Swallow so the chain settles cleanly.
+    if (err && err.message && err.message.startsWith('EXIT:')) return;
+    console.error(err ? err.message : String(err));
+    process.exit(1);
+  });
 }
 
 if (require.main === module) {
   main();
 }
 
-module.exports = { main };
+module.exports = { main, checkServer, newestSessionId, cmdKill, cmdList, cmdMigrate, windowFor, renderList, fmtClock, fmtDuration, fmtTokens, fmtCost, layoutCells, sessionInfoLines, centerIn };