agentp 2.0.0 → 2.1.0

package/bin/ocmux

@@ -5,26 +5,11 @@ const path = require('path');
 const readline = require('readline');
 const http = require('http');
 const { URL } = require('url');
-const { spawnSync } = require('child_process');
+const child_process = require('child_process');
 const os = require('os');
-const {
-  SESSION,
-  statefileFor,
-  tuiPaneId,
-  windowByDir,
-  windowNameByIndex,
-  activeWindowIndex,
-  listProjects,
-  activateProject,
-  relaunchTui,
-  closeProjectWindow,
-  createProjectWindow,
-  ensureSession,
-  pinWindowName,
-  sleep,
-  tuiAttachCommand,
-} = require('../lib/ocmux');
-const { listSessions, createSession, createSessionWithModel, updateSession, listModels, switchModel, resolveModelRef, getAuthHeaders, sortSessionsByRecency, deleteSession, listAgents, getActiveSessions } = require('../lib/opencode');
+const { tuiArgs, switchTui } = require('../lib/ocmux');
+const tuiRegistry = require('../lib/tui-registry');
+const { listSessions, listProjects: listOpenCodeProjects, createSession, createSessionWithModel, updateSession, listModels, switchModel, resolveModelRef, getAuthHeaders, sortSessionsByRecency, deleteSession, listAgents, getActiveSessions, getSession } = require('../lib/opencode');
 const projectState = require('../lib/project-state');
 
 // ---------------------------------------------------------------------------
@@ -41,15 +26,6 @@ const DEFAULT_SERVER = process.env.OCMUX_SERVER || 'http://localhost:4096';
 // Helpers
 // ---------------------------------------------------------------------------
 
-function tmux(args) {
-  const result = spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
-  if (result.error && result.error.code === 'ENOENT') {
-    console.error('Error: tmux is not installed or not in PATH');
-    process.exit(1);
-  }
-  return result;
-}
-
 function findParentStatefile(startDir) {
   let dir = path.resolve(startDir);
   while (true) {
@@ -93,18 +69,12 @@ 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 project window in the current directory.`);
+    console.error(`Run '${SCRIPT} serve' without ${flagLabel} to initialize the current directory.`);
     process.exit(1);
   }
   return result.dir;
 }
 
-function findWindowsByBasename(name) {
-  const r = tmux(['list-windows', '-t', SESSION, '-F', '#{window_name}']);
-  if (r.status !== 0) return [];
-  return r.stdout.trim().split('\n').filter(Boolean).filter(w => path.basename(w) === name);
-}
-
 function resolveDir(arg) {
   const resolved = path.resolve(arg);
   try {
@@ -112,17 +82,6 @@ function resolveDir(arg) {
   } catch {
     // not a valid path or inaccessible
   }
-
-  if (!arg.includes('/')) {
-    const matches = findWindowsByBasename(arg);
-    if (matches.length === 1) return matches[0];
-    if (matches.length > 1) {
-      console.error(`Error: more than one match for '${arg}':`);
-      for (const m of matches) console.error(`  ${m}`);
-      process.exit(1);
-    }
-  }
-
   console.error(`Error: invalid directory '${arg}'`);
   console.error(`Run '${SCRIPT} -h' for help.`);
   process.exit(1);
@@ -154,9 +113,51 @@ function checkServer(server) {
   });
 }
 
+function refreshTui(directory, server, session) {
+  const result = switchTui(directory, server, session, path.resolve(process.argv[1]));
+  if (!result.ok && result.reason === 'failed') {
+    console.error(`Warning: session selected, but the ${result.kind} TUI could not be refreshed: ${result.error}`);
+  }
+  return result;
+}
+
+async function configuredProjects(server) {
+  const [projects, sessions] = await Promise.all([
+    listOpenCodeProjects(server),
+    listSessions(server),
+  ]);
+  const rows = [];
+  const seen = new Set();
+  const directories = [
+    ...(projects || []).map(project => project.canonical || project.directory),
+    ...(sessions || []).map(session => session.location && session.location.directory),
+  ];
+  for (const dir of directories) {
+    if (!dir) continue;
+    let canonical;
+    try { canonical = fs.realpathSync(dir); } catch { canonical = path.resolve(dir); }
+    if (seen.has(canonical)) continue;
+    const sf = path.join(canonical, '.ocmux.json');
+    const state = projectState.readProjectState(sf);
+    if (!state) continue;
+    seen.add(canonical);
+    const target = tuiRegistry.resolve(canonical);
+    rows.push({
+      dir: canonical,
+      status: target ? target.kind : 'headless',
+      session: state.session,
+      server: state.server || server,
+    });
+  }
+  return rows.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
 function newestSessionId(sessions) {
   if (!sessions || sessions.length === 0) return null;
-  const sorted = sortSessionsByRecency(sessions).filter(s => s && s.id);
+  // Implicit targets skip child/subagent sessions (parentID set) — OpenCode's
+  // TUI opens those on its "Subagents" tab instead of the prompt. Callers fall
+  // back to creating a session when this returns null.
+  const sorted = sortSessionsByRecency(sessions).filter(s => s && s.id && !s.parentID);
   return sorted.length > 0 ? sorted[0].id : null;
 }
 
@@ -186,6 +187,134 @@ function padLeft(s, w) {
   const str = String(s);
   return ' '.repeat(Math.max(0, w - str.length)) + str;
 }
+
+// ── Palette (classic 16-colour ANSI) ─────────────────────────────────────────
+// Colour 3 renders as brown/dark-yellow; bold colour 3 as light yellow. The
+// whole list UI (title/status bars, cursor pointer, info labels) sticks to these
+// two shades so the chrome reads as one theme.
+const BROWN = '\x1b[33m';            // text: brown/dark-yellow
+const BAR_BG = '\x1b[30;43m';        // title/status bar: black on brown
+const LIGHT_YELLOW = '\x1b[1;33m';   // text: light-yellow (bold brown)
+
+// ── '/' incremental search for interactive lists ──────────────────────────
+// Filter `items` by `pattern`: case-insensitive, space-separated tokens that
+// must ALL be substrings of `textOf(item)`. Empty pattern → list unchanged.
+function filterByPattern(items, pattern, textOf) {
+  const p = String(pattern || '').trim().toLowerCase();
+  if (!p) return items;
+  const tokens = p.split(/\s+/);
+  return items.filter((it) => {
+    const hay = String(textOf(it) || '').toLowerCase();
+    return tokens.every((t) => hay.includes(t));
+  });
+}
+
+// State of a '/' search line: `active` a filter exists, `live` the user is
+// still typing into it, `value` the pattern, `caret` the edit position.
+function newSearchState() {
+  return { active: false, live: false, value: '', caret: 0 };
+}
+
+function clearSearchState(s) {
+  s.active = false;
+  s.live = false;
+  s.value = '';
+  s.caret = 0;
+}
+
+// Drive a '/' search line from a keypress. Returns:
+//   'edit'  — pattern/caret changed (caller re-filters and redraws)
+//   'close' — search cancelled/cleared (caller re-filters and redraws)
+//   'done'  — search committed, pattern kept (caller redraws)
+//   'pass'  — not handled here (caller runs its normal key logic)
+function handleSearch(str, key, s) {
+  if (str === '/' && !key.ctrl && !key.meta && !s.live) {
+    // '/' starts a new search or resumes editing the active filter.
+    if (!s.active) { s.value = ''; s.caret = 0; }
+    else s.caret = s.value.length;
+    s.active = true;
+    s.live = true;
+    return 'edit';
+  }
+  if (!s.active) return 'pass';
+  if (!s.live) {
+    // Committed filter: ESC drops it, Backspace resumes editing it.
+    if (key.name === 'escape') { clearSearchState(s); return 'close'; }
+    if (key.name === 'backspace') {
+      if (s.value === '') { clearSearchState(s); return 'close'; }
+      s.live = true;
+      s.caret = s.value.length;
+      s.value = s.value.slice(0, -1);
+      s.caret--;
+      return 'edit';
+    }
+    return 'pass';
+  }
+  // Live typing.
+  if (key.name === 'escape') { clearSearchState(s); return 'close'; }
+  if (key.name === 'return' || key.name === 'enter') {
+    if (!s.value.trim()) { clearSearchState(s); return 'close'; }
+    s.live = false;
+    return 'done';
+  }
+  if (key.name === 'backspace') {
+    // Backspace on an already-empty field exits the search (like ESC). Removing
+    // the last character keeps the field open.
+    if (s.value === '') { clearSearchState(s); return 'close'; }
+    if (s.caret > 0) {
+      s.value = s.value.slice(0, s.caret - 1) + s.value.slice(s.caret);
+      s.caret--;
+    }
+    return 'edit';
+  }
+  if (key.name === 'delete' || key.name === 'del') {
+    if (s.caret < s.value.length) s.value = s.value.slice(0, s.caret) + s.value.slice(s.caret + 1);
+    return 'edit';
+  }
+  if (key.name === 'left') { s.caret = Math.max(0, s.caret - 1); return 'done'; }
+  if (key.name === 'right') { s.caret = Math.min(s.value.length, s.caret + 1); return 'done'; }
+  if (key.name === 'home') { s.caret = 0; return 'done'; }
+  if (key.name === 'end') { s.caret = s.value.length; return 'done'; }
+  if (key.name === 'up' || key.name === 'down') return 'pass'; // navigate the filtered list
+  if (str && !key.ctrl && !key.meta && str >= ' ') {
+    s.value = s.value.slice(0, s.caret) + str + s.value.slice(s.caret);
+    s.caret += str.length;
+    return 'edit';
+  }
+  return 'pass';
+}
+
+// The status bar's search line: normal key hints, or the pattern while a '/'
+// filter is active (live = input with caret; committed = pattern kept).
+// The caller adds the `Enter: confirm · Esc: cancel` hint on the right via
+// renderList's `footerRight`.
+const SEARCH_HINT = 'Enter: confirm · Esc: cancel';
+function searchFooter(s, base) {
+  if (!s.active) return base;
+  const shown = s.live ? s.value.slice(0, s.caret) + '▏' + s.value.slice(s.caret) : s.value;
+  return s.live ? `Search: ${shown}` : `Search: ${shown} · /: edit`;
+}
+
+// ── Model picker ordering ─────────────────────────────────────────────────────
+// Models sorted by provider then id (the provider already leads the label, so
+// this is also alphabetical by display order).
+function sortModels(models) {
+  const key = (m) => `${String(m.providerID || '').toLowerCase()}/${String(m.id || '').toLowerCase()}`;
+  return [...(models || [])].sort((a, b) => (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0));
+}
+
+// Index of `model` (as stored on a session: { providerID, id }) inside
+// `models`, or -1 when unknown/unmatched — so a picker can open on it.
+function indexOfModel(models, model) {
+  if (!model || !models || !models.length) return -1;
+  const key = (m) => `${String(m.providerID || '').toLowerCase()}/${String(m.id || '').toLowerCase()}`;
+  const target = key(model);
+  return models.findIndex((m) => key(m) === target);
+}
+
+// Sentinel returned by switchMenu on Ctrl+C so the caller fully exits the CLI
+// (instead of just returning to the session menu).
+const SWITCH_QUIT = Symbol('ocmux-switch-quit');
 // Last-view stamp: HH:MM within the last 24h, else DD/MM/YYYY; '--:--' if unknown.
 function fmtClock(ts) {
   if (!ts) return '--:--';
@@ -270,13 +399,14 @@ function labeledLine(label, value, cols, labelColor = '\x1b[1m') {
   return `${labelColor}${lbl}\x1b[0m ${v}`;
 }
 
-// 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.
+// Info lines about the selected session: title + location and a responsive
+// grid. Fields are ALWAYS present (placeholders when unknown).
+// Labels are brown (the same shade as the title/status bars); when `highlight`
+// is true (the cursor is on the session currently selected in the TUI) they are
+// light-yellow instead.
 function sessionInfoLines(s, runningIds, modelContext, cols, highlight = false) {
   if (!s) return [];
-  const labelColor = highlight ? '\x1b[1;33m' : '\x1b[1m';
+  const labelColor = highlight ? LIGHT_YELLOW : BROWN;
   const title = (s.title && s.title.trim()) || 'Untitled';
   const location = (s.location && s.location.directory) || 'Unknown';
   const out = [
@@ -317,13 +447,15 @@ function sessionInfoLines(s, runningIds, modelContext, cols, highlight = false)
 }
 
 // Render a scrollable list into the alternate screen.
-//   heading    -> centered + bold + inverted heading
+//   heading    -> centered title bar (brown background)
 //   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)
+//   footer     -> status bar (brown background), key hints right-aligned
+//                 (left-aligned when footerLeft is set — used by the search line)
+//   footerRight-> optional hint pinned to the right end of a left-aligned footer
+//   infoLines  -> details below the status bar (colours supplied by the caller)
 // 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 }) {
+function renderList({ title, items, cursor, row, footer, infoLines = [], extraLines = [], cols: colsArg, rows: rowsArg, footerLeft = false, footerRight = null }) {
   const cols = colsArg || process.stdout.columns || 80;
   const termRows = rowsArg || process.stdout.rows || 24;
   const extras = (extraLines || []).filter((l) => l != null && l !== '');
@@ -341,7 +473,7 @@ function renderList({ title, items, cursor, row, footer, infoLines = [], extraLi
   }
 
   let out = '\x1b[2J\x1b[H';
-  out += '\x1b[1;7m' + centerIn(titleLine, cols) + '\x1b[0m\n\n';
+  out += BAR_BG + centerIn(titleLine, cols) + '\x1b[0m\n\n';
 
   let rendered = 0;
   if (items.length === 0) {
@@ -353,8 +485,11 @@ function renderList({ title, items, cursor, row, footer, infoLines = [], extraLi
       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';
+      // The pointer sits outside the row's own styling so a light-yellow arrow
+      // stays visible even on a reverse-video row.
+      const ptr = idx === cursor ? `${LIGHT_YELLOW}▶\x1b[0m ` : '  ';
+      const body = text == null ? '' : text;
+      out += ptr + (reverse ? `\x1b[7m${body}\x1b[0m` : body) + '\n';
       rendered++;
     }
   }
@@ -362,8 +497,22 @@ function renderList({ title, items, cursor, row, footer, infoLines = [], extraLi
   // (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';
+  let hint;
+  if (footerRight) {
+    // Left-aligned text plus a hint pinned to the right end of the bar.
+    const left = footer.length + footerRight.length + 1 <= cols
+      ? footer
+      : footer.slice(0, Math.max(0, cols - footerRight.length - 1));
+    const gap = Math.max(0, cols - left.length - footerRight.length);
+    hint = (left + ' '.repeat(gap) + footerRight).slice(0, cols);
+  } else if (footer.length > cols) {
+    hint = footer.slice(0, cols);
+  } else if (footerLeft) {
+    hint = footer + ' '.repeat(cols - footer.length);
+  } else {
+    hint = padLeft(footer, cols);
+  }
+  out += BAR_BG + hint + '\x1b[0m\n';
   for (const l of infos) out += l + '\n';
   return out.replace(/\n$/, '');
 }
@@ -374,7 +523,9 @@ function renderList({ title, items, cursor, row, footer, infoLines = [], extraLi
 // 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 } = {}) {
+// `dir` names the project this list belongs to — it heads the title bar so a
+// multi-project run always says which project's sessions are on screen.
+function sessionMenu(sessions, currentSession, annotations, server, { onPick, onRename, onDelete, onReminder, runningIds, modelContext, onBroadcastChange, onInspectSession, dir, notices = [] } = {}) {
   return new Promise((resolve) => {
     if (!process.stdin.isTTY) return resolve(null);
 
@@ -390,10 +541,17 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     let spinIdx = 0;
     let spinTimer = null;
+    let broadcastSel = new Set(); // session ids selected in broadcast mode
+    let search = newSearchState();    // '/' filter for the session list
+    let listSearch = newSearchState(); // '/' filter for inline lists (models/agents)
+    let view = rows;              // rows filtered by `search` (what is displayed)
+    let inspected = false;        // broadcast inspection moved the TUI off `current`
 
     const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
     const helpLines = [
-      'Enter / Space    switch to the selected session (stays open)',
+      'Enter            switch to the selected session (stays open)',
+      'Space            start BROADCAST: add the selected session to the current one',
+      '                 (Space toggles each session; Enter keeps the selection)',
       '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',
@@ -402,6 +560,8 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       'a                switch the AGENT of the selected session',
       'm                switch the MODEL of the selected session',
       'p                open the project switcher',
+      '/                search/filter this list (Enter keeps the filter,',
+      '                 ESC clears it, / resumes editing it)',
       'j / k, arrows    move the cursor',
       'h                toggle this help',
       'q / Ctrl+C       quit',
@@ -437,21 +597,45 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     };
 
     const draw = () => {
-      if (mode === 'help') {
+      if (mode === 'help' || mode === 'broadcast-help' || mode === 'list-help') {
         let out = '\x1b[2J\x1b[H';
-        out += 'ocmux session picker — help\n\n';
-        for (const l of helpLines) out += '  ' + l + '\n';
+        if (mode === 'broadcast-help') {
+          out += 'ocmux broadcast mode — help\n\n';
+          out += '  Space            select/deselect the cursor session\n';
+          out += '  Enter            keep the broadcast selection; switch TUI to cursor\n';
+          out += '  m                switch the model for ALL selected sessions\n';
+          out += '  d                delete the cursor session (with confirmation)\n';
+          out += '  j / k, arrows    move the cursor (selecting shows it in the TUI)\n';
+          out += '  /                search/filter the session list\n';
+          out += '  ESC / q          cancel broadcast mode (back to the session list)\n';
+          out += '  Ctrl+C           quit ocmux\n';
+        } else if (mode === 'list-help') {
+          out += `ocmux ${list && list.title ? list.title : 'list'} — help\n\n`;
+          out += '  j / k, arrows    move the cursor\n';
+          out += '  Enter / Space    select the highlighted item\n';
+          out += '  /                search/filter the list (Enter keeps, ESC clears)\n';
+          out += '  h                toggle this help\n';
+          out += '  ESC / q / Backspace   return to the previous menu\n';
+          out += '  Ctrl+C           quit ocmux\n';
+        } else {
+          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) {
+        const listExtras = (listSearch.active && list.view.length === 0) ? [`No matches for "${listSearch.value}"`] : [];
         process.stderr.write(renderList({
           title: `ocmux — ${list.title}`,
-          items: list.items,
+          items: list.view,
           cursor: listCursor,
           row: (i, item) => list.format(item) || '',
-          footer: 'Enter: select · ESC: back',
+          footer: searchFooter(listSearch, 'Enter: select · /: search · h: help · ESC: back'),
+          footerLeft: listSearch.active,
+          footerRight: listSearch.active ? SEARCH_HINT : null,
+          extraLines: listExtras,
         }));
         return;
       }
@@ -462,30 +646,46 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
         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) {
+      const inBc = mode === 'broadcast' || mode === 'broadcast-confirm';
+      const extras = [...notices];
+      if ((mode === 'confirm' || mode === 'broadcast-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);
+      if (search.active && view.length === 0) extras.push(`No sessions match "${search.value}"`);
+      const selected = view[cursor];
+      let infoLines = [];
+      let footer = 'Enter: switch · Space: broadcast · /: search · h: help · q: quit';
+      if (inBc) {
+        const names = rows.filter(r => broadcastSel.has(String(r.id))).map(r => r.title || r.id).join(', ');
+        infoLines = [`Broadcast to sessions: ${names}`];
+        footer = 'Enter: switch · Space: toggle · d: delete · m: model · /: search · h: help · q: cancel · Ctrl+C: quit';
+      } else {
+        const selIsCurrent = !!(selected && String(selected.id) === String(current));
+        infoLines = sessionInfoLines(selected, runningIds, modelContext, cols, selIsCurrent);
+      }
+      footer = searchFooter(search, footer);
       process.stderr.write(renderList({
-        title: 'ocmux — sessions',
-        items: rows,
+        // The project name heads the title so you always know which project's
+        // sessions are listed (matters when --all-projects moves you around).
+        title: dir ? `ocmux — ${path.basename(dir)} sessions` : 'ocmux — sessions',
+        items: view,
         cursor,
         row: (i, s) => {
+          const sel = inBc ? (broadcastSel.has(String(s.id)) ? '[x] ' : '[ ] ') : '';
           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;
+          const text = `${sel}${spin}${timeStr}${pad(title, maxLen)}${mark}${hasNote}`;
+          // Brown for the session currently selected in the TUI window.
+          return String(s.id) === String(current) ? `${BROWN}${text}\x1b[0m` : text;
         },
-        footer: 'Enter: switch · h: help · q: quit',
+        footer,
+        footerLeft: search.active,
+        footerRight: search.active ? SEARCH_HINT : null,
         infoLines,
         extraLines: extras,
       }));
@@ -498,7 +698,7 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     };
 
     const applyRenameWith = (name) => {
-      const row = rows[cursor];
+      const row = view[cursor];
       if (!row || !onRename || !name) return;
       Promise.resolve(onRename(row, name)).then((updated) => {
         row.title = (updated && updated.title) || name;
@@ -510,7 +710,7 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     };
 
     const applyReminder = (text) => {
-      const row = rows[cursor];
+      const row = view[cursor];
       if (!row || !onReminder) return;
       Promise.resolve(onReminder(row, text)).then((saved) => {
         if (saved) annotations[row.id] = saved;
@@ -526,11 +726,14 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       Promise.resolve(onPick ? onPick(row) : null).then((created) => {
         if (row.new && created) {
           rows.unshift(created);
+          applySearch();
+          const ci = view.indexOf(created);
+          cursor = ci >= 0 ? ci : 0;
           current = created.id;
-          cursor = 0;
         } else if (!row.new) {
           current = row.id;
         }
+        inspected = false;
         confirmDel = null;
         draw();
       }).catch((err) => {
@@ -543,28 +746,105 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
     const applyDelete = () => {
       const s = confirmDel;
       if (!s || !onDelete) return;
+      const wasBroadcast = mode === 'broadcast-confirm';
       Promise.resolve(onDelete(s)).then(() => {
         rows = rows.filter(r => r.id !== s.id);
-        if (cursor >= rows.length && cursor > 0) cursor = rows.length - 1;
+        applySearch();
+        if (cursor >= view.length && cursor > 0) cursor = view.length - 1;
         confirmDel = null;
-        mode = 'normal';
-        draw();
+        if (wasBroadcast) {
+          broadcastSel.delete(String(s.id));
+          if (broadcastSel.size < 2) {
+            // Broadcast ended: make the remaining selected session the real
+            // selection (switch the TUI to it and store it).
+            const remaining = [...broadcastSel][0];
+            persistBroadcast([]);
+            broadcastSel = new Set();
+            mode = 'normal';
+            const row = rows.find(r => String(r.id) === String(remaining));
+            if (row) applyPick(row);
+            else { draw(); }
+          } else {
+            persistBroadcast([...broadcastSel]);
+            mode = 'broadcast';
+            draw();
+          }
+        } else {
+          mode = 'normal';
+          draw();
+        }
       }).catch((err) => {
         process.stderr.write(`\nError: ${err.message}\n`);
         confirmDel = null;
-        mode = 'normal';
+        mode = wasBroadcast ? 'broadcast' : 'normal';
         draw();
       });
     };
 
-    const openList = (title, items, format, onEnter) => {
+    const persistBroadcast = (ids) => {
+  if (onBroadcastChange) onBroadcastChange(ids);
+};
+    // Recompute the filtered session view after `rows` or the pattern change.
+    const applySearch = () => {
+      view = filterByPattern(rows, search.active ? search.value : '',
+        (r) => `${r.title || ''} ${r.id || ''}`);
+      if (cursor >= view.length) cursor = Math.max(0, view.length - 1);
+    };
+    // Recompute the filtered view of the currently open inline list.
+    const applyListSearch = () => {
+      if (!list) return;
+      list.view = filterByPattern(list.items, listSearch.active ? listSearch.value : '', list.format);
+      if (listCursor >= list.view.length) listCursor = Math.max(0, list.view.length - 1);
+    };
+    // After a broadcast attempt (cancel / drop below two): put the menu — and
+    // the TUI — back on the stored current session, which inspection may have
+    // relaunched away without updating `.ocmux.json`.
+    const restoreCurrent = () => {
+      const idx = view.findIndex((r) => String(r.id) === String(current));
+      if (idx >= 0) cursor = idx;
+      if (inspected && current != null && onInspectSession) onInspectSession(current);
+      inspected = false;
+    };
+    const startBroadcast = (idx) => {
+  broadcastSel = new Set([String(current), String(view[idx].id)]);
+  persistBroadcast([...broadcastSel]);
+  mode = 'broadcast';
+  if (onInspectSession) { onInspectSession(view[idx].id); inspected = true; }
+  draw();
+};
+const toggleBroadcast = (idx) => {
+  const id = String(view[idx].id);
+  const adding = !broadcastSel.has(id);
+  if (adding) broadcastSel.add(id);
+  else broadcastSel.delete(id);
+  if (adding && onInspectSession) { onInspectSession(id); inspected = true; }
+  if (broadcastSel.size < 2) {
+    // Deselecting down to one session ends broadcast mode by making that
+    // remaining session the actual selection.
+    const remaining = [...broadcastSel][0];
+    persistBroadcast([]);
+    broadcastSel = new Set();
+    mode = 'normal';
+    const row = rows.find(r => String(r.id) === String(remaining));
+    if (row) applyPick(row);
+    else { restoreCurrent(); draw(); }
+    return;
+  }
+  persistBroadcast([...broadcastSel]);
+  draw();
+};
+
+    // `startCursor` lets a picker open with the cursor already on the relevant
+    // entry (the model pickers open on the current model).
+    const openList = (title, items, format, onEnter, returnMode = 'normal', startCursor = 0) => {
       if (!items || items.length === 0) {
         process.stderr.write(`\nNo ${title.toLowerCase()} available.\n`);
         draw();
         return;
       }
-      list = { title, items, format, onEnter };
-      listCursor = 0;
+      list = { title, items, view: items, format, onEnter, returnMode };
+      listSearch = newSearchState();
+      listCursor = Math.max(0, Math.min(startCursor, items.length - 1));
       mode = 'list';
       draw();
     };
@@ -574,17 +854,36 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       draw();
     };
 
+    // Open the model picker with the list sorted by provider and the cursor
+    // already on `session`'s current model (so `m` starts where the change is).
+    const openModelPicker = (title, session, returnMode, onPick) => {
+      listModels(server).then((models) => {
+        const sorted = sortModels(models);
+        openList(title, sorted, (x) => `${x.label}${x.variant ? `#${x.variant}` : ''}`,
+          onPick, returnMode, indexOfModel(sorted, session && session.model));
+      }).catch(commandErr);
+    };
+
     process.stdin.on('keypress', (str, key) => {
-      if (mode === 'help') {
-        mode = 'normal';
+      // Ctrl+C always fully exits ocmux, from any menu.
+      if (key.ctrl && key.name === 'c') {
+        if (mode === 'broadcast' || mode === 'broadcast-confirm') {
+          persistBroadcast([]);
+          broadcastSel = new Set();
+          restoreCurrent();
+        }
+        return finish(null);
+      }
+      if (mode === 'help' || mode === 'broadcast-help' || mode === 'list-help') {
+        mode = mode === 'broadcast-help' ? 'broadcast' : (mode === 'list-help' ? 'list' : 'normal');
         draw();
         return;
       }
-      if (mode === 'confirm') {
+      if (mode === 'confirm' || mode === 'broadcast-confirm') {
         if (key.name === 'y') return applyDelete();
         if (key.name === 'n' || key.name === 'escape' || key.name === 'q' || key.name === 'return') {
           confirmDel = null;
-          mode = 'normal';
+          mode = mode === 'broadcast-confirm' ? 'broadcast' : 'normal';
           draw();
         }
         return;
@@ -638,27 +937,81 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
         return;
       }
       if (mode === 'list') {
+        const lr = handleSearch(str, key, listSearch);
+        if (lr !== 'pass') { applyListSearch(); draw(); return; }
         if (key.name === 'escape' || key.name === 'q' || key.name === 'backspace') {
+          const returnMode = list.returnMode;
           list = null;
-          mode = 'normal';
+          mode = returnMode;
+          draw();
+        } else if (key.name === 'h') {
+          mode = 'list-help';
           draw();
         } else if (key.name === 'up' || str === 'k') {
-          listCursor = (listCursor - 1 + list.items.length) % list.items.length;
+          if (list.view.length) listCursor = (listCursor - 1 + list.view.length) % list.view.length;
           draw();
         } else if (key.name === 'down' || str === 'j') {
-          listCursor = (listCursor + 1) % list.items.length;
+          if (list.view.length) listCursor = (listCursor + 1) % list.view.length;
           draw();
         } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
-          const item = list.items[listCursor];
+          const item = list.view[listCursor];
+          if (item === undefined) { draw(); return; }
           const onEnter = list.onEnter;
+          const returnMode = list.returnMode;
           list = null;
-          mode = 'normal';
+          mode = returnMode;
           draw();
           Promise.resolve(onEnter(item)).then(() => draw()).catch(commandErr);
         }
         return;
       }
-      if (key.ctrl && key.name === 'c') return finish(null);
+      const sr = handleSearch(str, key, search);
+      if (sr !== 'pass') { applySearch(); draw(); return; }
+      if (mode === 'broadcast') {
+        if (key.name === 'escape') {
+          persistBroadcast([]);
+          broadcastSel = new Set();
+          mode = 'normal';
+          restoreCurrent();
+          draw();
+        } else if (key.name === 'q') {
+          // 'q' only quits from the plain session list; in broadcast mode it
+          // cancels back to that list (Ctrl+C quits from anywhere).
+          persistBroadcast([]);
+          broadcastSel = new Set();
+          mode = 'normal';
+          restoreCurrent();
+          draw();
+        } else if (key.name === 'h') {
+          mode = 'broadcast-help';
+          draw();
+        } else if (key.name === 'space') {
+          if (cursor < view.length) toggleBroadcast(cursor);
+        } else if (key.name === 'd') {
+          if (cursor < view.length) {
+            confirmDel = view[cursor];
+            mode = 'broadcast-confirm';
+            draw();
+          }
+        } else if (key.name === 'm') {
+          openModelPicker('Broadcast model (all selected sessions)', view[cursor], 'broadcast', async (item) => {
+            await Promise.all([...broadcastSel].map(id => switchModel(server, id, item)));
+          });
+        } else if (key.name === 'return' || key.name === 'enter') {
+          if (cursor < view.length) {
+            mode = 'normal';
+            broadcastSel = new Set(); // selection stays persisted for agentp
+            applyPick(view[cursor]);
+          }
+        } else if (view.length > 0 && (key.name === 'up' || str === 'k')) {
+          cursor = (cursor - 1 + view.length) % view.length;
+          draw();
+        } else if (view.length > 0 && (key.name === 'down' || str === 'j')) {
+          cursor = (cursor + 1) % view.length;
+          draw();
+        }
+        return;
+      }
       if (key.name === 'q') return finish(null);
       if (key.name === 'p') return finish('switch-project');
       if (key.name === 'h') {
@@ -672,17 +1025,17 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
       }
       // Shift+r → Reminder; lowercase r → Rename.
       if (str === 'R') {
-        const row = rows[cursor];
+        const row = view[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');
+      if (key.name === 'r' && cursor < view.length) {
+        startInput('Rename to (ESC cancels):', view[cursor].title || '', 'rename');
         return;
       }
       if (key.name === 'a') {
-        const target = rows[cursor];
+        const target = view[cursor];
         if (target) {
           listAgents(server).then((all) => {
             const primary = all.filter(x => x.mode === 'primary' && !x.hidden);
@@ -694,31 +1047,33 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
         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);
-        }
+        const target = view[cursor];
+        if (target) openModelPicker('Models', target, 'normal', (item) => switchModel(server, target.id, item));
         return;
       }
       if (key.name === 'd') {
-        if (cursor < rows.length) {
-          confirmDel = rows[cursor];
+        if (cursor < view.length) {
+          confirmDel = view[cursor];
           mode = 'confirm';
           draw();
         }
         return;
       }
-      if (rows.length > 0 && (key.name === 'up' || str === 'k')) {
-        cursor = (cursor - 1 + rows.length) % rows.length;
+      if (view.length > 0 && (key.name === 'up' || str === 'k')) {
+        cursor = (cursor - 1 + view.length) % view.length;
         draw();
-      } else if (rows.length > 0 && (key.name === 'down' || str === 'j')) {
-        cursor = (cursor + 1) % rows.length;
+      } else if (view.length > 0 && (key.name === 'down' || str === 'j')) {
+        cursor = (cursor + 1) % view.length;
         draw();
-      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
-        if (cursor < rows.length) applyPick(rows[cursor]);
+      } else if (key.name === 'return' || key.name === 'enter') {
+        if (cursor < view.length) applyPick(view[cursor]);
+      } else if (key.name === 'space') {
+        // Start broadcast only when adding a DIFFERENT session to the current one.
+        if (cursor < view.length && String(view[cursor].id) !== String(current)) {
+          startBroadcast(cursor);
+        } else if (cursor < view.length) {
+          draw(); // no-op on the already-selected session
+        }
       }
     });
 
@@ -735,8 +1090,19 @@ function sessionMenu(sessions, currentSession, annotations, server, { onPick, on
   });
 }
 
-// Interactive project picker — purely visual/navigation, never writes state.
-function switchMenu(rows, longMode) {
+// Interactive project picker — never writes state (it only moves what a
+// registered dedicated/shared TUI displays).
+//
+// Default (safe): an INSPECTOR. Selecting a project/session row still focuses
+// the routed TUI and shows the session there, but the promise always resolves to
+// null, so the caller re-opens its own project's list. Nothing about the
+// caller's project changes.
+//
+// `{ allProjects: true }` (CLI `--all-projects`): a real SWITCHER. Selecting a
+// row also records the target directory, so the caller moves its picker there
+// and can then write that project's `.ocmux.json` — the file `agentp` reads in
+// that directory.
+function switchMenu(rows, { allProjects = false, onOpen } = {}) {
   return new Promise((resolve) => {
     if (!process.stdin.isTTY) {
       console.error('Error: "switch" is interactive and requires a TTY.');
@@ -756,17 +1122,53 @@ function switchMenu(rows, longMode) {
     const lineWidth = Math.max(cols, nameW + 2 + stsW + 2 + ssnW + 6);
 
     let cursor = 0;
-    let activeRow = 0;
-    let lastDir = null;
+    let lastDir = null;       // target dir to move to (only with allProjects)
     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; }
+    let help = false;
+    const search = newSearchState();
+    let view = [];              // flattened nodes: { kind:'project'|'session', ... }
+    // Fold state per project directory: { open, sessions, loading, error }.
+    const folds = new Map();
+
+    const foldOf = (p) => folds.get(p.dir) || { open: false, sessions: null, loading: false, error: null };
+    const projectText = (p) => `${path.basename(p.dir)} ${p.dir} ${p.session || ''}`;
+    const sessionText = (s) => `${s.title || ''} ${s.id || ''}`;
+    const matches = (pattern, text) => filterByPattern([1], pattern, () => text).length > 0;
+
+    // Flatten projects (plus their unfolded sessions) honouring the '/' pattern.
+    // A project header survives when it matches itself OR when one of its
+    // unfolded sessions does, so a match deeper down is still navigable.
+    const buildView = () => {
+      const pattern = search.active ? search.value : '';
+      const out = [];
+      for (const p of rows) {
+        const f = foldOf(p);
+        const sessions = f.open && f.sessions ? f.sessions : [];
+        const shown = sessions.filter((s) => matches(pattern, sessionText(s)));
+        const header = { kind: 'project', project: p };
+        if (sessions.length === 0) {
+          if (matches(pattern, projectText(p))) out.push(header);
+        } else if (matches(pattern, projectText(p)) || shown.length) {
+          out.push(header);
+          for (const s of shown) out.push({ kind: 'session', project: p, session: s });
+        }
       }
+      return out;
+    };
+
+    const sameNode = (a, b) => {
+      if (!a || !b || a.kind !== b.kind || a.project.dir !== b.project.dir) return false;
+      return a.kind !== 'session' || a.session.id === b.session.id;
+    };
+
+    const applySearch = () => {
+      const prev = view[cursor];
+      view = buildView();
+      const idx = prev ? view.findIndex((n) => sameNode(n, prev)) : -1;
+      if (idx >= 0) cursor = idx;
+      else if (cursor >= view.length) cursor = Math.max(0, view.length - 1);
     };
+    applySearch();
 
     const cleanup = () => {
       process.stderr.write('\x1b[?25h');
@@ -775,58 +1177,165 @@ function switchMenu(rows, longMode) {
       try { process.stdin.setRawMode(false); } catch {}
     };
 
-    const finish = () => {
+    const finish = (value) => {
       if (done) return;
       done = true;
       cleanup();
       process.stdin.pause();
-      resolve(lastDir);
+      process.stdin.removeAllListeners('keypress');
+      process.removeListener('SIGINT', onSig);
+      resolve(value === undefined ? lastDir : value);
     };
 
+    // Mode-dependent wording: the switcher inspects by default and really
+    // switches only under --all-projects.
+    const switcherTitle = allProjects ? 'ocmux — project switcher (all projects)' : 'ocmux — project switcher';
+    const enterHint = allProjects ? 'Enter: switch' : 'Enter: view';
+    const modeNote = allProjects
+      ? ['--all-projects: selecting moves the picker to that project, so a',
+         'session picked there updates ITS .ocmux.json — the file agentp',
+         'reads when it runs in that directory.']
+      : ['Selecting only moves the TUI view — .ocmux.json is never',
+         'written, so agentp keeps prompting your own project’s session.',
+         'You always come back to your own project’s list.'];
+
     const draw = () => {
-      refreshActive();
+      if (done) return;
+      if (help) {
+        let out = '\x1b[2J\x1b[H';
+        out += 'ocmux project switcher — help\n\n';
+        out += '  j / k, arrows    move the cursor (projects and sessions)\n';
+        out += `  Enter            ${allProjects ? 'switch the picker to the selected project' : 'focus the selected project (menu stays open)'}\n`;
+        out += '                   (on a session, show it in that project’s TUI)\n';
+        out += '  Space            fold/unfold a project’s sessions;\n';
+        out += '                   on a session, show it in the TUI as well\n';
+        out += '  /                search/filter the list (Enter keeps, ESC clears)\n';
+        out += '  h                toggle this help\n';
+        out += '  q                return to the session menu\n';
+        out += '  Ctrl+C           quit ocmux\n';
+        out += '\n';
+        for (const l of modeNote) out += `${l}\n`;
+        out += '\nPress any key to return.\n';
+        process.stderr.write(out);
+        return;
+      }
+      const extras = [];
+      if (search.active && view.length === 0) extras.push(`No projects match "${search.value}"`);
+      for (const n of view) {
+        if (n.kind !== 'project') continue;
+        const f = folds.get(n.project.dir);
+        if (!f || !f.open) continue;
+        const name = path.basename(n.project.dir);
+        if (f.loading) extras.push(`  … loading sessions of ${name} …`);
+        else if (f.error) extras.push(`  ! ${name}: ${f.error}`);
+      }
       process.stderr.write(renderList({
-        title: 'ocmux — project switcher',
-        items: rows,
+        title: switcherTitle,
+        items: view,
         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;
+        row: (i, node) => {
+          if (node.kind === 'session') {
+            const s = node.session;
+            const id = String(s.id || '');
+            const mark = String(s.id) === String(node.project.session) ? '  *' : '';
+            const title = (s.title || id).slice(0, Math.max(8, nameW + 6));
+            return `  ${title}${mark}  ${id}`;
+          }
+          const p = node.project;
+          const fold = foldOf(p).open ? '▾' : '▸';
+          const session = p.session ? p.session.slice(0, 14) : '(none)';
+          const text = `${fold} ${pad(path.basename(p.dir), nameW)}  ${pad(p.status, stsW)}  ${pad(session, ssnW)}  ${p.dir}`;
+          return text;
         },
-        footer: 'Enter: focus · q: quit',
+        footer: searchFooter(search, `${enterHint} · Space: fold · /: search · h: help · q: back · Ctrl+C: quit`),
+        footerLeft: search.active,
+        footerRight: search.active ? SEARCH_HINT : null,
+        extraLines: extras,
       }));
     };
 
-    const activate = (i) => {
-      const row = rows[i];
+    // Enter on a project row: show its current session in its routed TUI. With
+    // allProjects off this stays a pure inspection and
+    // `lastDir` is left null so the caller returns to its own project.
+    const activate = (p) => {
+      if (!p) return;
       try {
-        if (row.server) {
-          activateProject(row.dir, row.index, row.server, row.session);
-        } else {
-          tmux(['select-window', '-t', `${SESSION}:${row.index}`]);
-        }
-        lastDir = row.dir;
+        if (p.server && p.session && onOpen) onOpen(p, p.session);
+        if (allProjects) lastDir = p.dir;
+      } catch (err) {
+        process.stderr.write(`\nError: ${err.message}\n`);
+      }
+      draw();
+    };
+
+    // Enter/Space on a session row: move the TUI VIEW onto it. The switcher
+    // itself never writes `.ocmux.json`; with allProjects on the caller only
+    // moves its picker to that project — the write happens later, when a
+    // session is picked there (and that file is what agentp reads there).
+    const openSession = (node) => {
+      const p = node.project;
+      try {
+        if (p.server && onOpen) onOpen(p, node.session.id);
+        if (allProjects) lastDir = p.dir;
       } catch (err) {
         process.stderr.write(`\nError: ${err.message}\n`);
       }
       draw();
     };
 
-    const onSig = () => finish();
+    // Space on a project row: fetch its sessions once, then flip the fold.
+    const toggleFold = (p) => {
+      const f = folds.get(p.dir) || { open: false, sessions: null, loading: false, error: null };
+      folds.set(p.dir, f);
+      if (!f.open && !f.sessions && !f.error && !f.loading) {
+        if (!p.server) {
+          f.error = 'no server recorded';
+        } else {
+          f.loading = true;
+          f.open = true;
+          applySearch();
+          draw();
+          listSessions(p.server, p.dir)
+            .then((list) => {
+              // Main sessions only: child/subagent sessions are work products,
+              // not navigation targets (same rule as the session picker).
+              f.sessions = sortSessionsByRecency((list || []).filter((s) => !s.parentID));
+            })
+            .catch((err) => { f.error = err.message; })
+            .then(() => { f.loading = false; applySearch(); draw(); });
+          return;
+        }
+      }
+      f.open = !f.open;
+      applySearch();
+      draw();
+    };
+
+    const onSig = () => finish(SWITCH_QUIT);
     process.on('SIGINT', onSig);
 
     process.stdin.on('keypress', (str, key) => {
-      if (key.ctrl && key.name === 'c') return finish();
+      // Ctrl+C fully exits ocmux; 'q' only closes this menu (back to sessions).
+      if (key.ctrl && key.name === 'c') return finish(SWITCH_QUIT);
+      if (help) { help = false; draw(); return; }
+      const sr = handleSearch(str, key, search);
+      if (sr !== 'pass') { applySearch(); draw(); return; }
+      if (key.name === 'h') { help = true; draw(); return; }
       if (key.name === 'q') return finish();
+      if (view.length === 0) return;
+      const node = view[cursor];
       if (key.name === 'up' || str === 'k') {
-        cursor = (cursor + rows.length - 1) % rows.length;
+        cursor = (cursor + view.length - 1) % view.length;
         draw();
       } else if (key.name === 'down' || str === 'j') {
-        cursor = (cursor + 1) % rows.length;
+        cursor = (cursor + 1) % view.length;
         draw();
-      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
-        activate(cursor);
+      } else if (key.name === 'return' || key.name === 'enter') {
+        if (node.kind === 'project') activate(node.project);
+        else openSession(node);
+      } else if (key.name === 'space') {
+        if (node.kind === 'project') toggleFold(node.project);
+        else openSession(node);
       }
     });
 
@@ -843,13 +1352,18 @@ function switchMenu(rows, longMode) {
 // Subcommand: default — interactive session switcher for the current project
 // ---------------------------------------------------------------------------
 
-async function cmdSessionSwitch(targetDir, directRef) {
+// `allProjects` (CLI `--all-projects`) unlocks cross-project switching: the
+// project switcher may then move this picker onto another project, whose
+// `.ocmux.json` gets written when a session is picked there. Without it the
+// switcher is inspection-only and this command always stays on `targetDir`'s
+// project.
+async function cmdSessionSwitch(targetDir, directRef, allProjects = false) {
   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.`);
+    console.error(`Run 'ocmux serve' to initialize the project.`);
       process.exit(1);
     }
     const state = projectState.readProjectState(sf);
@@ -868,22 +1382,28 @@ async function cmdSessionSwitch(targetDir, directRef) {
       process.exit(1);
     }
 
-    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);
-    }
-
-    // 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 notices = [];
+    if (state.session && !sorted.some(s => String(s.id) === String(state.session))) {
+      try {
+        const moved = await getSession(server, state.session);
+        const movedDir = moved && moved.location && moved.location.directory;
+        if (movedDir && path.resolve(movedDir) !== path.resolve(dir)) {
+          notices.push(`⚠ Current session moved to ${movedDir}`);
+          notices.push(`  Run: ocmux serve ${JSON.stringify(movedDir)} --server ${JSON.stringify(server)}`);
+        }
+      } catch {
+        // A deleted/stale stored session is handled by the normal picker.
+      }
+    }
+    // Only "main" sessions are listed in the picker: exclude child/subagent
+    // sessions (parentID set) — they are work products of a main session, not
+    // targets. Explicit --session can still reach one by id/title.
+    const mainSessions = sorted.filter(s => !s.parentID);
     const annotations = projectState.readAnnotations(sf);
     const runningIds = await getActiveSessions(server);
     let modelContext = new Map();
@@ -894,7 +1414,7 @@ async function cmdSessionSwitch(targetDir, directRef) {
 
     const applySession = (id) => {
       projectState.writeProjectState(sf, { session: id });
-      relaunchTui(winIdx, dir, server, id);
+      refreshTui(dir, server, id);
     };
 
     if (directRef) {
@@ -910,19 +1430,22 @@ async function cmdSessionSwitch(targetDir, directRef) {
     }
 
     if (!process.stdin.isTTY) {
-      // Silent path (non-TTY): just make sure the window is focused.
-      activateProject(dir, winIdx, server, state.session);
+      // Silent path (non-TTY): project state already identifies the target.
       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;
+    let lastRef = (state.session && mainSessions.find(s => String(s.id) === String(state.session))) || mainSessions[0] || null;
     const result = await new Promise((resolve) => {
-      sessionMenu(sorted, state.session, annotations, server, {
+      sessionMenu(mainSessions, state.session, annotations, server, {
+        dir,
         runningIds,
         modelContext,
+        notices,
+        onBroadcastChange: (ids) => projectState.writeProjectState(sf, { broadcast: ids }),
+        onInspectSession: (id) => refreshTui(dir, server, id),
         onPick: async (row) => {
           if (row.new) {
             const created = await createSessionWithModel(server, row.name || undefined, dir, [lastRef, ...sorted]).catch((err) => {
@@ -963,12 +1486,21 @@ async function cmdSessionSwitch(targetDir, directRef) {
     });
 
     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;
+      // 'p' pressed: open the project switcher. Without --all-projects it only
+      // inspects (picked stays null => re-run this picker for the same
+      // project); with it, picking a project re-runs the picker there.
+      // Ctrl+C fully exits.
+      const rows = await configuredProjects(server).catch((err) => {
+        console.error(`Error listing projects: ${err.message}`);
+        return [];
+      });
+      const picked = await switchMenu(rows, {
+        allProjects,
+        onOpen: (project, id) => refreshTui(project.dir, project.server, id),
+      });
+      if (picked === SWITCH_QUIT) break;
+      if (!picked) continue;
+      target = picked;
       continue;
     }
     break;
@@ -976,7 +1508,7 @@ async function cmdSessionSwitch(targetDir, directRef) {
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: serve — create a project TUI window (server is user-managed)
+// Subcommand: serve — initialize project/session state (server is user-managed)
 // ---------------------------------------------------------------------------
 
 async function cmdServeNew(targetDir, serverArg, force) {
@@ -985,7 +1517,7 @@ async function cmdServeNew(targetDir, serverArg, force) {
   const sf = path.join(targetDir, '.ocmux.json');
   if (fs.existsSync(sf)) {
     if (!force) {
-      console.error(`Error: a project window already exists in ${targetDir}.`);
+      console.error(`Error: project state already exists in ${targetDir}.`);
       console.error(`Use 'ocmux' to switch sessions there, or 'ocmux serve --server <url> --force' to repoint it.`);
       process.exit(1);
     }
@@ -995,11 +1527,10 @@ async function cmdServeNew(targetDir, serverArg, force) {
   const parent = findParentStatefile(path.dirname(targetDir));
   if (parent) {
     const parentDir = path.dirname(parent);
-    console.error(`Warning: there is already an opencode project in ${parentDir}.`);
-    console.error(`Run 'ocmux' and press 'p' to move between project windows.`);
+    console.error(`Warning: there is already an ocmux project in ${parentDir}.`);
 
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    rl.question('Are you sure you want to create a new project window here? [y/N] ', (answer) => {
+    rl.question('Are you sure you want to initialize a nested project here? [y/N] ', (answer) => {
       rl.close();
       if (!/^[yY]([eE][sS])?$/.test(answer.trim())) {
         console.error('Cancelled.');
@@ -1015,8 +1546,8 @@ async function cmdServeNew(targetDir, serverArg, force) {
   return doServeNew(targetDir, serverArg);
 }
 
-// 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.
+// Repoint an existing project to a (possibly new) server. A registered TUI is
+// refreshed through the normal dedicated → shared routing rule.
 async function doForceServe(targetDir, sf, server) {
   const alive = await checkServer(server);
   if (!alive) {
@@ -1037,14 +1568,8 @@ async function doForceServe(targetDir, sf, server) {
     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}).`);
-  }
+  refreshTui(targetDir, server, session);
+  console.error(`Repointed ${targetDir} to ${server} (session ${session}).`);
 }
 
 async function doServeNew(targetDir, serverArg) {
@@ -1076,108 +1601,181 @@ async function doServeNew(targetDir, serverArg) {
     }
   }
 
-  console.error(`Creating project window for ${targetDir} (session ${session})...`);
-  try {
-    createProjectWindow(targetDir, server, session);
-  } catch (err) {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
+  projectState.writeProjectState(path.join(targetDir, '.ocmux.json'), {
+    directory: targetDir,
+    server,
+    session,
+    status: 'active',
+  });
+  refreshTui(targetDir, server, session);
+  console.error(`Initialized ${targetDir} → ${server} (session ${session}).`);
 }
 
 // ---------------------------------------------------------------------------
-// Subcommand: list
+// Subcommand: tui — register this tmux pane and host an OpenCode TUI
 // ---------------------------------------------------------------------------
 
-function cmdList(longMode) {
-  const rows = listProjects();
-  if (rows.length === 0) {
-    console.log('No opencode projects running.');
-    return;
-  }
-
-  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.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}`);
+async function cmdTui(targetDir, serverArg, shared, sessionArg) {
+  const tmuxTarget = tuiRegistry.parseTmuxEnvironment();
+  if (!tmuxTarget) {
+    console.error("Error: 'ocmux tui' must run inside a tmux pane.");
+    process.exit(1);
   }
-}
-
-// ---------------------------------------------------------------------------
-// Subcommand: kill — close the project window but keep .ocmux.json
-// ---------------------------------------------------------------------------
-
-function cmdKill(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' first.");
+    process.exit(1);
+  }
+  const state = projectState.readProjectState(sf);
+  const directory = state.directory;
+  const server = serverArg || state.server || DEFAULT_SERVER;
+  if (!await checkServer(server)) {
+    console.error(`Error: OpenCode server not reachable at ${server}.`);
     process.exit(1);
   }
-  const serverDir = path.dirname(sf);
-  const winIdx = windowByDir(serverDir);
-  if (winIdx != null) {
-    console.error(`Closing project window for ${serverDir}...`);
+
+  let session = sessionArg || state.session;
+  if (session) {
     try {
-      closeProjectWindow(winIdx);
-    } catch (err) {
-      console.error(`Error: ${err.message}`);
-      process.exit(1);
+      const found = await getSession(server, session);
+      if (found.location && found.location.directory) targetDir = found.location.directory;
+    } catch {
+      session = null;
     }
-  } else {
-    console.error(`Tmux window not found for ${serverDir} (state kept).`);
   }
-  // Session memory intentionally kept.
-  projectState.writeProjectState(sf, { status: 'stopped' });
-  console.error('Done (state file kept).');
-}
+  if (!session) {
+    const sessions = await listSessions(server, directory);
+    session = newestSessionId(sessions);
+    if (!session) session = (await createSessionWithModel(server, undefined, directory, sessions)).id;
+    projectState.writeProjectState(sf, { session, server });
+  }
 
-// ---------------------------------------------------------------------------
-// Subcommand: resurrect — recreate a project window from its state
-// ---------------------------------------------------------------------------
+  const registration = tuiRegistry.register({
+    ...tmuxTarget,
+    shared,
+    directory: shared ? targetDir : directory,
+    server,
+    session,
+    pid: process.pid,
+  });
+
+  const instance = registration.instance;
+  const launchDir = targetDir || directory;
+  const child = child_process.spawn('opencode', tuiArgs(server, session, launchDir), {
+    cwd: launchDir,
+    stdio: 'inherit',
+  });
+  tuiRegistry.updateInstance(instance.id, instance.token, { childPid: child.pid || null });
 
-async function cmdResurrect(targetDir) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const forward = (signal) => {
+      try { child.kill(signal); } catch {}
+    };
+    const onHup = () => forward('SIGHUP');
+    const onTerm = () => forward('SIGTERM');
+    const onInt = () => forward('SIGINT');
+    process.on('SIGHUP', onHup);
+    process.on('SIGTERM', onTerm);
+    process.on('SIGINT', onInt);
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      process.removeListener('SIGHUP', onHup);
+      process.removeListener('SIGTERM', onTerm);
+      process.removeListener('SIGINT', onInt);
+      tuiRegistry.unregister(instance.id, instance.token);
+      if (err) reject(err);
+      else resolve();
+    };
+    child.once('error', finish);
+    child.once('exit', () => finish());
+  });
+}
+
+function tuiProjectDirectory(targetDir) {
   const sf = findParentStatefile(targetDir);
-  if (!sf) {
+  if (!sf) return null;
+  const state = projectState.readProjectState(sf);
+  return state && state.directory;
+}
+
+function formatTuiRegistration(instance) {
+  return `${instance.shared ? 'shared' : 'project'}  ${instance.pane}  ${instance.directory || '(none)'}  ${instance.server || '(none)'}  ${instance.session || '(none)'}`;
+}
+
+function cmdTuiList() {
+  const instances = tuiRegistry.list();
+  if (instances.length === 0) {
+    console.log('No registered TUIs.');
+    return;
+  }
+  console.log('Kind     Pane  Directory  Server  Session');
+  for (const instance of instances) console.log(formatTuiRegistration(instance));
+}
+
+function cmdTuiStatus(targetDir, shared) {
+  const directory = shared ? null : tuiProjectDirectory(targetDir);
+  if (!shared && !directory) {
     console.error(`Error: no .ocmux.json found in ${targetDir} or any of its parents.`);
     process.exit(1);
   }
-  const state = projectState.readProjectState(sf);
-  const server = state.server;
-  if (!server) {
-    console.error(`Error: ${sf} does not record a server.`);
+  const instance = shared ? tuiRegistry.shared() : tuiRegistry.dedicated(directory);
+  if (!instance) {
+    console.log(shared ? 'Shared TUI: not registered' : `Project TUI: not registered (${directory})`);
+    return;
+  }
+  console.log(formatTuiRegistration(instance));
+}
+
+function cmdTuiDetach(targetDir, shared) {
+  const directory = shared ? null : tuiProjectDirectory(targetDir);
+  if (!shared && !directory) {
+    console.error(`Error: no .ocmux.json found in ${targetDir} or any of its parents.`);
     process.exit(1);
   }
-  const dir = state.directory;
+  const instance = shared ? tuiRegistry.shared() : tuiRegistry.dedicated(directory);
+  if (!instance) {
+    console.log(shared ? 'Shared TUI was not registered.' : `Project TUI was not registered (${directory}).`);
+    return;
+  }
+  tuiRegistry.unregister(instance.id, instance.token);
+  console.log(`Detached ${shared ? 'shared' : 'project'} TUI from ${instance.pane}.`);
+}
 
-  const winIdx = windowByDir(dir);
-  if (winIdx != null) {
-    console.error(`Project window for ${dir} already exists.`);
+// ---------------------------------------------------------------------------
+// Subcommand: list
+// ---------------------------------------------------------------------------
+
+async function cmdList(longMode, server) {
+  const rows = await configuredProjects(server);
+  if (rows.length === 0) {
+    console.log('No configured ocmux projects found.');
     return;
   }
 
-  const alive = await checkServer(server);
-  if (!alive) {
-    console.error(`Error: OpenCode server not reachable at ${server}.`);
-    process.exit(1);
+  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.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}`);
   }
-  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();
+async function cmdMigrate(server) {
+  const rows = await configuredProjects(server);
   let migrated = 0;
   for (const row of rows) {
-    const sf = statefileFor(row.dir);
+    const sf = projectState.statefileFor(row.dir);
     const state = projectState.readProjectState(sf);
     if (!state) continue;
     if (state.version >= 2) continue;
@@ -1198,31 +1796,39 @@ function cmdMigrate() {
 // ---------------------------------------------------------------------------
 
 function printHelp() {
-  console.error(`Usage: ${SCRIPT} [-l] [<subcommand>] [<directory>]`);
+  console.error(`Usage: ${SCRIPT} [-l] [--all-projects] [<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('Manage project/session routing and optional registered OpenCode TUIs.');
+  console.error('The OpenCode server is user-managed: start it 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('project (requires a TTY). The title bar names the project whose');
+  console.error('sessions are listed. 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('Selecting updates .ocmux.json and refreshes a dedicated TUI, falling');
+  console.error('back to the shared TUI. Silent on success. (p opens projects; by');
+  console.error('default it only inspects other projects and never modifies any');
+  console.error('.ocmux.json — see --all-projects.)');
   console.error('');
   console.error('Subcommands:');
-  console.error('  serve     Create a TUI window for <directory> (default: $PWD).');
+  console.error('  serve     Initialize project state 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('  tui [--shared] [--server <url>] [directory]');
+  console.error('            Register the current tmux pane and run its OpenCode TUI.');
+  console.error('            Without --shared it is dedicated to the current project;');
+  console.error('            --shared makes it the single fallback for every project.');
+  console.error('            --list lists all live registrations; --status inspects one;');
+  console.error('            --detach unregisters one without closing its pane or TUI.');
+  console.error('            With --status/--detach, --shared targets the shared slot;');
+  console.error('            otherwise the slot dedicated to directory is targeted.');
   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('  list [-l] List configured projects and TUI routing status.');
   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');
@@ -1230,6 +1836,12 @@ function printHelp() {
   console.error('');
   console.error('Options:');
   console.error('  -l          Long output (list: also show server URL).');
+  console.error('  --all-projects');
+  console.error('                  Let the picker’s project switcher (p) MOVE to another');
+  console.error('                  project, so picking a session there updates that');
+  console.error('                  project’s .ocmux.json (what agentp reads in it).');
+  console.error('                  Default: the switcher only inspects other projects');
+  console.error('                  and you always return to your own project’s list.');
   console.error('  --version   Show version');
   console.error('  -h          Show this help');
   console.error('');
@@ -1247,8 +1859,13 @@ function main() {
   let gitMode = null;
   let serverArg = null;
   let force = false;
+  let allProjects = false;
+  let sharedTui = false;
+  let tuiSession = null;
+  let tuiList = false;
+  let tuiStatus = false;
+  let tuiDetach = false;
   const positional = [];
-  let dirIsForced = false;
 
   const parsedArgs = process.argv.slice(2);
   for (let i = 0; i < parsedArgs.length; i++) {
@@ -1269,6 +1886,24 @@ function main() {
       process.exit(1);
     } else if (arg === '--force') {
       force = true;
+    } else if (arg === '--shared') {
+      sharedTui = true;
+    } else if (arg === '--session-id') {
+      const val = parsedArgs[i + 1];
+      if (!val || val.startsWith('-')) {
+        console.error("Error: '--session-id' requires a session ID.");
+        process.exit(1);
+      }
+      tuiSession = val;
+      i++;
+    } else if (arg === '--list') {
+      tuiList = true;
+    } else if (arg === '--status') {
+      tuiStatus = true;
+    } else if (arg === '--detach') {
+      tuiDetach = true;
+    } else if (arg === '--all-projects') {
+      allProjects = true;
     } else if (arg === '--git') {
       if (gitMode && gitMode !== 'nearest') {
         console.error("Error: cannot combine '--git' with '--GIT'.");
@@ -1287,13 +1922,19 @@ function main() {
     } else if (arg === '-h' || arg === '--help') {
       printHelp();
     } else if (arg === '--') {
-      dirIsForced = true;
+      const directory = parsedArgs[i + 1];
+      if (!directory) {
+        console.error("Error: '--' requires a directory argument.");
+        process.exit(1);
+      }
+      positional.push({ value: directory, forcedDirectory: true });
+      i++;
     } else if (arg.startsWith('-')) {
       console.error(`Error: unknown option '${arg}'`);
       console.error(`Run '${SCRIPT} -h' for help.`);
       process.exit(1);
     } else {
-      positional.push(arg);
+      positional.push({ value: arg, forcedDirectory: false });
     }
   }
 
@@ -1303,16 +1944,16 @@ function main() {
   let targetDir = null;
   let directRef = null;
 
-  for (const arg of positional) {
-    if (dirIsForced) {
-      dirIsForced = false;
+  for (const positionalArg of positional) {
+    const arg = positionalArg.value;
+    if (positionalArg.forcedDirectory) {
       if (targetDir) {
         console.error(`Error: unexpected argument '${arg}'`);
         process.exit(1);
       }
       targetDir = resolveDir(arg);
-    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list'
-      || arg === 'resurrect' || arg === 'session'
+    } else if (arg === 'serve' || arg === 'new' || arg === 'list' || arg === 'tui'
+      || arg === 'session'
       || arg === 'migrate') {
       if (subcommand) {
         console.error(`Error: multiple subcommands specified: '${subcommand}' and '${arg}'`);
@@ -1332,6 +1973,23 @@ function main() {
 
   if (!targetDir) targetDir = process.cwd();
 
+  if (sharedTui && subcommand !== 'tui') {
+    console.error("Error: '--shared' is only valid with 'ocmux tui'.");
+    process.exit(1);
+  }
+  if (tuiSession && subcommand !== 'tui') {
+    console.error("Error: '--session-id' is only valid with 'ocmux tui'.");
+    process.exit(1);
+  }
+  if ((tuiList || tuiStatus || tuiDetach) && subcommand !== 'tui') {
+    console.error("Error: '--list', '--status', and '--detach' are only valid with 'ocmux tui'.");
+    process.exit(1);
+  }
+  if ([tuiList, tuiStatus, tuiDetach].filter(Boolean).length > 1) {
+    console.error("Error: combine at most one of '--list', '--status', and '--detach'.");
+    process.exit(1);
+  }
+
   // 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.
@@ -1346,28 +2004,45 @@ function main() {
       console.error("Error: 'list' does not accept a directory path.");
       process.exit(1);
     }
-    ensureSession();
-    cmdList(longMode);
-  } else if (subcommand === 'session') {
-    if (gitMode) {
-      console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
+    p = cmdList(longMode, serverArg || DEFAULT_SERVER);
+  } else if (subcommand === 'tui') {
+    if (gitMode || force || allProjects || longMode) {
+      console.error("Error: 'tui' does not accept --git, --GIT, --force, --all-projects, or -l.");
       process.exit(1);
     }
-    p = cmdSessionSwitch(targetDir, directRef);
-  } else if (subcommand === 'kill') {
+    if (tuiList) {
+      if (sharedTui || serverArg || tuiSession || targetDir !== process.cwd()) {
+        console.error("Error: 'ocmux tui --list' does not accept --shared, --server, --session-id, or a directory.");
+        process.exit(1);
+      }
+      cmdTuiList();
+    } else if (tuiStatus) {
+      if (serverArg || tuiSession) {
+        console.error("Error: 'ocmux tui --status' does not accept --server or --session-id.");
+        process.exit(1);
+      }
+      cmdTuiStatus(targetDir, sharedTui);
+    } else if (tuiDetach) {
+      if (serverArg || tuiSession) {
+        console.error("Error: 'ocmux tui --detach' does not accept --server or --session-id.");
+        process.exit(1);
+      }
+      cmdTuiDetach(targetDir, sharedTui);
+    } else {
+      p = cmdTui(targetDir, serverArg, sharedTui, tuiSession);
+    }
+  } else if (subcommand === 'session') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    cmdKill(targetDir);
-  } else if (subcommand === 'resurrect') {
-    p = cmdResurrect(targetDir);
+    p = cmdSessionSwitch(targetDir, directRef, allProjects);
   } else if (subcommand === 'migrate') {
     if (targetDir !== process.cwd()) {
       console.error("Error: 'migrate' does not accept a directory path.");
       process.exit(1);
     }
-    cmdMigrate();
+    p = cmdMigrate(serverArg || DEFAULT_SERVER);
   } else if (subcommand === 'serve' || subcommand === 'new') {
     if (gitMode) {
       const flagLabel = gitMode === 'root' ? '--GIT' : '--git';
@@ -1380,7 +2055,7 @@ function main() {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
       process.exit(1);
     }
-    p = cmdSessionSwitch(targetDir, null);
+    p = cmdSessionSwitch(targetDir, null, allProjects);
   }
 
   return p.catch((err) => {
@@ -1396,4 +2071,4 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { main, checkServer, newestSessionId, cmdKill, cmdList, cmdMigrate, windowFor, renderList, fmtClock, fmtDuration, fmtTokens, fmtCost, layoutCells, sessionInfoLines, centerIn };
+module.exports = { main, checkServer, newestSessionId, configuredProjects, refreshTui, cmdTui, cmdTuiList, cmdTuiStatus, cmdTuiDetach, cmdList, cmdMigrate, windowFor, renderList, fmtClock, fmtDuration, fmtTokens, fmtCost, layoutCells, sessionInfoLines, centerIn, filterByPattern, newSearchState, handleSearch, searchFooter, sessionMenu, switchMenu, SWITCH_QUIT, SEARCH_HINT, sortModels, indexOfModel, BROWN, BAR_BG, LIGHT_YELLOW };