@bramblex/codex-workbench 0.1.19 → 0.1.21

package/README.md

@@ -18,7 +18,7 @@ codex-workbench is an **interactive terminal UI** for coding-agent sessions. Ins
 
 It also connects to **remote machines over SSH**, so you can manage sessions across all your servers from a single pane of glass.
 
-Built-in backends currently include [Codex](https://github.com/openai/codex), pi, and opencode. The backend layer is intentionally provider-based so additional agents can be added without changing the TUI workflow.
+Built-in backends currently include [Codex](https://github.com/openai/codex), Claude Code, pi, and opencode. The backend layer is intentionally provider-based so additional agents can be added without changing the TUI workflow.
 
 A handful of CLI subcommands are available for scripting, but the TUI is the product.
 
@@ -136,6 +136,7 @@ codex-workbench auto-detects installed backends by checking each backend's sessi
 | Backend | Sessions | Binary override | Notes |
 |---------|----------|-----------------|-------|
 | `codex` | `$CODEX_SESSIONS_DIR` or `~/.codex/sessions` | `CODEX_BIN` | Uses the Codex CLI for new, resume, fork, archive, unarchive, and delete. |
+| `claude` | `$CLAUDE_PROJECTS_DIR` or `~/.claude/projects` | `CLAUDE_BIN` | Uses the Claude Code CLI for new, resume, and fork. Archive/unarchive use workbench metadata; delete removes the session file. |
 | `pi` | `$PI_CODING_AGENT_SESSION_DIR` or `$PI_CODING_AGENT_DIR/sessions` | `PI_BIN` | Uses the pi CLI for new, resume, and fork. Archive/unarchive use workbench metadata; delete removes the session file. |
 | `opencode` | `$OPENCODE_DB`, `$OPENCODE_DATA_DIR/opencode.db`, or `~/.local/share/opencode/opencode.db` | `OPENCODE_BIN` | Uses the opencode CLI and database for list, new, resume, fork, archive, unarchive, and delete. |
 
@@ -165,6 +166,7 @@ cwb fork <session>
 cwb delete <session> --force
 
 cwb new --cwd ~/projects/foo --backend codex "Summarize this repo"
+cwb new --cwd ~/projects/foo --backend claude "Summarize this repo"
 cwb new --cwd ~/projects/foo --backend pi "Summarize this repo"
 cwb new --cwd ~/projects/foo --backend opencode "Summarize this repo"
 cwb resume <session> "what was the conclusion about the rate limiter?"
@@ -191,6 +193,8 @@ When you run `new` or `resume`, the selected backend takes over the terminal. Wh
 | `CWB_CONFIG` | `$CWB_HOME/config.json` | SSH remote sources config |
 | `CODEX_HOME` | `~/.codex` | Codex data directory |
 | `CODEX_SESSIONS_DIR` | `$CODEX_HOME/sessions` | Session JSONL files |
+| `CLAUDE_HOME` | `~/.claude` | Claude Code data directory |
+| `CLAUDE_PROJECTS_DIR` | `$CLAUDE_HOME/projects` | Claude Code project session JSONL files |
 | `PI_CODING_AGENT_DIR` | `~/.pi/agent` | pi coding agent data directory |
 | `PI_CODING_AGENT_SESSION_DIR` | `$PI_CODING_AGENT_DIR/sessions` | pi session JSONL files |
 | `OPENCODE_DATA_DIR` | `~/.local/share/opencode` | opencode data directory |
@@ -198,6 +202,7 @@ When you run `new` or `resume`, the selected backend takes over the terminal. Wh
 | `CODEX_WORKBENCH_META` | unset | Legacy override for `CWB_META` |
 | `CODEX_WORKBENCH_CONFIG` | unset | Legacy override for `CWB_CONFIG` |
 | `CODEX_BIN` | auto-detected | Force a specific Codex executable |
+| `CLAUDE_BIN` | auto-detected | Force a specific Claude Code executable |
 | `PI_BIN` | auto-detected | Force a specific pi executable |
 | `OPENCODE_BIN` | auto-detected | Force a specific opencode executable |
 
@@ -223,6 +228,10 @@ Run `codex-workbench doctor` to see where codex-workbench is looking. Common fix
 
 Make sure you've run Codex at least once. Sessions are stored as `.jsonl` files under `$CODEX_SESSIONS_DIR`. Run `ls ~/.codex/sessions/` to verify.
 
+### No Claude Code sessions appear
+
+Make sure you've run Claude Code at least once. Sessions are stored as `.jsonl` files under `$CLAUDE_PROJECTS_DIR`. Run `find ~/.claude/projects -name '*.jsonl'` to verify.
+
 ### No pi sessions appear
 
 Make sure you've run the pi coding agent at least once. Sessions are stored as `.jsonl` files under `$PI_CODING_AGENT_SESSION_DIR` or `$PI_CODING_AGENT_DIR/sessions`. Run `ls ~/.pi/agent/sessions/` to verify.
@@ -293,6 +302,7 @@ src/
     workbench-config.js      # SSH remote source config loader
   providers/
     codex.js                 # Codex provider
+    claude.js                # Claude Code provider
     pi.js                    # pi provider
     opencode.js              # opencode provider
     index.js                 # provider registry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bramblex/codex-workbench",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Terminal workbench for browsing and managing local and SSH Codex sessions.",
   "license": "MIT",
   "repository": {

package/src/cli-output.js

@@ -31,6 +31,8 @@ Environment:
   CWB_CONFIG            default: $CWB_HOME/config.json
   CODEX_HOME            default: ~/.codex
   CODEX_SESSIONS_DIR    default: $CODEX_HOME/sessions
+  CLAUDE_HOME           default: ~/.claude
+  CLAUDE_PROJECTS_DIR   default: $CLAUDE_HOME/projects
   PI_CODING_AGENT_DIR   default: ~/.pi/agent
   PI_CODING_AGENT_SESSION_DIR default: $PI_CODING_AGENT_DIR/sessions
   OPENCODE_DATA_DIR     default: ~/.local/share/opencode
@@ -38,6 +40,7 @@ Environment:
   CODEX_WORKBENCH_META  legacy override for CWB_META
   CODEX_WORKBENCH_CONFIG legacy override for CWB_CONFIG
   CODEX_BIN             default: codex from shell PATH
+  CLAUDE_BIN            default: claude from shell PATH
   PI_BIN                default: pi from shell PATH
   OPENCODE_BIN          default: opencode from shell PATH
 `);

package/src/providers/claude.js

@@ -0,0 +1,283 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Claude Code provider – session parsing, binary discovery, and CLI operations
+// ---------------------------------------------------------------------------
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { removeMetadata, updateMetadata } = require('../model/metadata');
+
+const HOME = os.homedir();
+const CLAUDE_HOME = process.env.CLAUDE_HOME || path.join(HOME, '.claude');
+const CLAUDE_PROJECTS_DIR = process.env.CLAUDE_PROJECTS_DIR || path.join(CLAUDE_HOME, 'projects');
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function isExecutable(file) {
+  try { fs.accessSync(file, fs.constants.X_OK); return true; } catch { return false; }
+}
+
+function findOnPath(command, pathValue) {
+  for (const dir of (pathValue || process.env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, command);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+function executableFromOutput(output) {
+  for (const line of String(output || '').split(/\r?\n/)) {
+    const candidate = line.trim();
+    if (candidate && path.isAbsolute(candidate) && isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+function runShellLookup(shell, shellArgs, command, env) {
+  const result = spawnSync(shell, [...shellArgs, `command -v ${shellQuote(command)}`], {
+    encoding: 'utf8',
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error || result.status !== 0) return null;
+  return executableFromOutput(result.stdout);
+}
+
+function findWithShell(command, env) {
+  const shell = (env || process.env).SHELL || '/bin/sh';
+  if (!isExecutable(shell)) return null;
+  return runShellLookup(shell, ['-lc'], command, env) ||
+    runShellLookup(shell, ['-ic'], command, env);
+}
+
+function resolveClaudeBin() {
+  const env = process.env;
+  if (env.CLAUDE_BIN) {
+    if (isExecutable(env.CLAUDE_BIN)) return env.CLAUDE_BIN;
+    throw new Error(`CLAUDE_BIN is not executable: ${env.CLAUDE_BIN}`);
+  }
+  const fromShell = findWithShell('claude', env);
+  if (fromShell) return fromShell;
+  const fromPath = findOnPath('claude', env.PATH);
+  if (fromPath) return fromPath;
+  throw new Error('Could not find the claude executable. Set CLAUDE_BIN or add claude to PATH.');
+}
+
+function commandShell() {
+  const shell = process.env.SHELL || '/bin/sh';
+  try { fs.accessSync(shell, fs.constants.X_OK); return shell; } catch { return '/bin/sh'; }
+}
+
+function usableCwd(dir) {
+  for (const candidate of [dir, process.cwd(), HOME]) {
+    if (!candidate || candidate === '(unknown)') continue;
+    try { if (fs.statSync(candidate).isDirectory()) return candidate; } catch { /* skip */ }
+  }
+  return HOME;
+}
+
+function walk(dir, out) {
+  out = out || [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, out);
+    else if (entry.isFile() && entry.name.endsWith('.jsonl')) out.push(full);
+  }
+  return out;
+}
+
+function textFromContent(content) {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => {
+      if (!item) return '';
+      if (typeof item === 'string') return item;
+      if (item.type === 'text') return item.text || '';
+      if (item.type === 'tool_result') return '';
+      return '';
+    })
+    .filter(Boolean)
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function firstUserText(messages) {
+  const message = messages.find((msg) => msg.role === 'user');
+  return message ? message.text : '';
+}
+
+function lastText(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (!role || messages[i].role === role) return messages[i].text;
+  }
+  return '';
+}
+
+function isNoiseUserText(text) {
+  return /^<local-command-/.test(text) ||
+    /^<command-name>/.test(text) ||
+    text.includes('<environment_context>') ||
+    text.includes('<permissions instructions>');
+}
+
+function emptySession(file, stat) {
+  return {
+    id: path.basename(file, '.jsonl'),
+    file,
+    cwd: '(unknown)',
+    startedAt: stat.birthtime?.toISOString() || null,
+    updatedAt: stat.mtime.toISOString(),
+    cliVersion: '',
+    provider: '',
+    turns: 0,
+    first: '',
+    last: '',
+    lastAssistant: '',
+    messages: [],
+    backend: 'claude',
+  };
+}
+
+function parseSession(file) {
+  const stat = fs.statSync(file);
+  const raw = fs.readFileSync(file, 'utf8').trim();
+  if (!raw) return emptySession(file, stat);
+
+  const messages = [];
+  let id = path.basename(file, '.jsonl');
+  let cwd = '';
+  let startedAt = '';
+  let updatedAt = stat.mtime.toISOString();
+  let cliVersion = '';
+  let provider = '';
+  let turns = 0;
+
+  for (const line of raw.split(/\n/)) {
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+
+    if (row.sessionId) id = row.sessionId;
+    if (row.cwd) cwd = row.cwd;
+    if (row.version) cliVersion = row.version;
+    if (row.timestamp) {
+      if (!startedAt) startedAt = row.timestamp;
+      updatedAt = row.timestamp;
+    }
+
+    if ((row.type === 'user' || row.type === 'assistant') && row.message) {
+      const role = row.message.role || row.type;
+      const text = textFromContent(row.message.content);
+      if (!text) continue;
+      if (role === 'user' && isNoiseUserText(text)) continue;
+      messages.push({ role, text });
+      if (role === 'user') turns += 1;
+      if (!provider && role === 'assistant' && row.message.model) provider = row.message.model;
+    }
+  }
+
+  return {
+    id,
+    file,
+    cwd: cwd || '(unknown)',
+    startedAt: startedAt || stat.birthtime?.toISOString() || null,
+    updatedAt,
+    cliVersion,
+    provider,
+    turns,
+    first: firstUserText(messages),
+    last: lastText(messages, 'user'),
+    lastAssistant: lastText(messages, 'assistant'),
+    messages,
+    backend: 'claude',
+  };
+}
+
+function runArgv(argv, cwd, inherit) {
+  const shellCommand = `exec ${argv.map(shellQuote).join(' ')}`;
+  const shell = commandShell();
+  if (inherit) {
+    const child = spawn(shell, ['-lc', shellCommand], { stdio: 'inherit', cwd, env: process.env });
+    child.on('error', (err) => { console.error(`error: failed to start claude: ${err.message}`); process.exit(1); });
+    child.on('exit', (code, signal) => { if (signal) process.kill(process.pid, signal); process.exit(code || 0); });
+    return undefined;
+  }
+  const result = spawnSync(shell, ['-lc', shellCommand], { stdio: 'inherit', cwd, env: process.env });
+  if (result.error) throw new Error(`failed to start claude: ${result.error.message}`);
+  const status = typeof result.status === 'number' ? result.status : 1;
+  process.exitCode = status;
+  return status;
+}
+
+function runSessionCommand(command, session, args, inherit) {
+  const executable = resolveClaudeBin();
+  const cwd = usableCwd(session.cwd);
+  switch (command) {
+    case 'resume': {
+      const argv = [executable, '--resume', session.id];
+      if (args && args.length) argv.push(args.join(' '));
+      return runArgv(argv, cwd, inherit);
+    }
+    case 'fork': {
+      return runArgv([executable, '--resume', session.id, '--fork-session'], cwd, inherit);
+    }
+    case 'delete': {
+      fs.unlinkSync(session.file);
+      removeMetadata(session);
+      return 0;
+    }
+    case 'archive':
+    case 'unarchive': {
+      updateMetadata(session, { archived: command === 'archive' });
+      return 0;
+    }
+    default:
+      throw new Error(`Unknown command for claude backend: ${command}`);
+  }
+}
+
+function runNew(cwd, args, inherit) {
+  const argv = [resolveClaudeBin(), ...(args || [])];
+  return runArgv(argv, usableCwd(cwd), inherit);
+}
+
+function isAvailable() {
+  try { return fs.statSync(CLAUDE_PROJECTS_DIR).isDirectory(); } catch { return false; }
+}
+
+function getSessionFiles() {
+  return walk(CLAUDE_PROJECTS_DIR);
+}
+
+function resolveBin() {
+  try { return resolveClaudeBin(); } catch { return null; }
+}
+
+module.exports = {
+  id: 'claude',
+  label: 'Claude Code',
+  capabilities: {
+    new: true,
+    resume: true,
+    fork: true,
+    archive: true,
+    unarchive: true,
+    delete: true,
+  },
+  isAvailable,
+  getSessionFiles,
+  parseSession,
+  resolveBin,
+  runCommand: runSessionCommand,
+  runNew,
+  resolveClaudeBin,
+};

package/src/providers/index.js

@@ -5,10 +5,11 @@
 // ---------------------------------------------------------------------------
 
 const codex = require('./codex');
+const claude = require('./claude');
 const opencode = require('./opencode');
 const pi = require('./pi');
 
-const ALL_PROVIDERS = [codex, pi, opencode];
+const ALL_PROVIDERS = [codex, pi, opencode, claude];
 const providerMap = new Map(ALL_PROVIDERS.map((p) => [p.id, p]));
 
 /**
@@ -59,6 +60,7 @@ module.exports = {
   getProvider,
   providerForSession,
   getAllSessionFiles,
+  claude,
   codex,
   opencode,
   pi,

package/src/providers/opencode.js

@@ -24,6 +24,35 @@ function findOnPath(command, pathValue) {
   return null;
 }
 
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function executableFromOutput(output) {
+  for (const line of String(output || '').split(/\r?\n/)) {
+    const candidate = line.trim();
+    if (candidate && path.isAbsolute(candidate) && isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+function runShellLookup(shell, shellArgs, command, env) {
+  const result = spawnSync(shell, [...shellArgs, `command -v ${shellQuote(command)}`], {
+    encoding: 'utf8',
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error || result.status !== 0) return null;
+  return executableFromOutput(result.stdout);
+}
+
+function findWithShell(command, env) {
+  const shell = (env || process.env).SHELL || '/bin/sh';
+  if (!isExecutable(shell)) return null;
+  return runShellLookup(shell, ['-lc'], command, env) ||
+    runShellLookup(shell, ['-ic'], command, env);
+}
+
 function resolveOpenCodeBin() {
   if (process.env.OPENCODE_BIN) {
     if (isExecutable(process.env.OPENCODE_BIN)) return process.env.OPENCODE_BIN;
@@ -31,6 +60,8 @@ function resolveOpenCodeBin() {
   }
   const fromPath = findOnPath('opencode', process.env.PATH);
   if (fromPath) return fromPath;
+  const fromShell = findWithShell('opencode', process.env);
+  if (fromShell) return fromShell;
   throw new Error('Could not find the opencode executable. Set OPENCODE_BIN or add opencode to PATH.');
 }
 

package/src/ui/directory-picker.js

@@ -6,13 +6,23 @@ const blessed = require('blessed');
 const { createChildDirectory, directoryNameError, listDirectories } = require('../model/directories');
 
 const DEFAULT_HELP = '↑/↓ move  ←/h parent  →/l child  n new directory  Enter choose selected  Esc/q cancel';
+const color = (hex) => blessed.colors.match(hex);
+
+const FALLBACK_THEME = {
+  bg: color('#101216'),
+  surface: color('#151a21'),
+  text: color('#e5e7eb'),
+  textInverse: color('#0b0f14'),
+  project: color('#22c55e'),
+  danger: color('#f87171'),
+};
 
 const DEFAULT_OPS = {
   listDirectories: (dir) => listDirectories(dir),
   createDirectory: (parent, name) => createChildDirectory(parent, name),
 };
 
-function createDirectoryPicker({ screen, askInput, focusOnClose, truncate }) {
+function createDirectoryPicker({ screen, askInput, focusOnClose, theme = FALLBACK_THEME, truncate }) {
   const list = blessed.list({
     parent: screen,
     label: ' Choose directory ',
@@ -25,11 +35,13 @@ function createDirectoryPicker({ screen, askInput, focusOnClose, truncate }) {
     mouse: true,
     keys: true,
     vi: false,
-    scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'green' } },
+    scrollbar: { ch: ' ', track: { bg: theme.surface }, style: { bg: theme.project } },
     style: {
-      border: { fg: 'green' },
-      selected: { fg: 'black', bg: 'green', bold: true },
-      item: { fg: 'white' },
+      bg: theme.bg,
+      border: { fg: theme.project, bg: theme.bg },
+      label: { fg: theme.project, bg: theme.bg },
+      selected: { fg: theme.textInverse, bg: theme.project, bold: true },
+      item: { fg: theme.text, bg: theme.bg },
     },
   });
 
@@ -42,7 +54,12 @@ function createDirectoryPicker({ screen, askInput, focusOnClose, truncate }) {
     border: 'line',
     padding: { left: 1, right: 1 },
     content: DEFAULT_HELP,
-    style: { border: { fg: 'green' }, fg: 'white', bg: 'black' },
+    style: {
+      bg: theme.surface,
+      border: { fg: theme.project, bg: theme.surface },
+      fg: theme.text,
+      label: { fg: theme.project, bg: theme.surface },
+    },
   });
 
   let state = null;
@@ -51,7 +68,8 @@ function createDirectoryPicker({ screen, askInput, focusOnClose, truncate }) {
 
   const setHelp = (text = DEFAULT_HELP, isError = false) => {
     help.setContent(text);
-    help.style.fg = isError ? 'red' : 'white';
+    help.style.fg = isError ? theme.danger : theme.text;
+    help.style.bg = theme.surface;
   };
 
   const entriesFor = (dir) => {

package/src/ui/workbench.js

@@ -24,6 +24,40 @@ const { usableCwd } = require('../services/codex-runner');
 const { checkForUpdate } = require('../services/update-checker');
 const { createDirectoryPicker } = require('./directory-picker');
 
+const color = (hex) => blessed.colors.match(hex);
+
+const THEME = {
+  bg: color('#101216'),
+  surface: color('#151a21'),
+  surfaceRaised: color('#1f2630'),
+  surfaceMuted: color('#343b46'),
+  text: color('#e5e7eb'),
+  textMuted: color('#8b95a1'),
+  textInverse: color('#0b0f14'),
+  borderIdle: color('#3f4652'),
+  accent: color('#38bdf8'),
+  accentAlt: color('#2563eb'),
+  project: color('#22c55e'),
+  detail: color('#f59e0b'),
+  warning: color('#facc15'),
+  danger: color('#f87171'),
+  success: color('#34d399'),
+  tag: {
+    accent: 'cyan',
+    detail: 'yellow',
+    muted: 'gray',
+    text: 'white',
+    warning: 'yellow',
+  },
+  backend: {
+    claude: 'yellow',
+    codex: 'cyan',
+    opencode: 'green',
+    pi: 'magenta',
+    unknown: 'blue',
+  },
+};
+
 async function runWorkbench() {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     return printList(loadWorkbenchSessions().sessions);
@@ -45,6 +79,7 @@ async function runWorkbench() {
   let remoteLoading = false;
   let updateInfo = null;
   let closed = false;
+  let searchQuery = '';
 
   const screen = blessed.screen({
     smartCSR: true,
@@ -52,6 +87,15 @@ async function runWorkbench() {
     title: appTitle,
   });
 
+  blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    style: { bg: THEME.bg },
+  });
+
   const header = blessed.box({
     parent: screen,
     top: 0,
@@ -59,7 +103,7 @@ async function runWorkbench() {
     right: 0,
     height: 3,
     padding: { left: 1, right: 1 },
-    style: { fg: 'white', bg: 'blue' },
+    style: { fg: THEME.text, bg: THEME.accentAlt },
     content: appTitle,
   });
 
@@ -75,11 +119,13 @@ async function runWorkbench() {
     keys: true,
     vi: false,
     tags: true,
-    scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'green' } },
+    scrollbar: { ch: ' ', track: { bg: THEME.surface }, style: { bg: THEME.project } },
     style: {
-      border: { fg: 'green' },
-      selected: { fg: 'black', bg: 'green', bold: true },
-      item: { fg: 'white' },
+      bg: THEME.bg,
+      border: { fg: THEME.project, bg: THEME.bg },
+      label: { fg: THEME.project, bg: THEME.bg },
+      selected: { fg: THEME.textInverse, bg: THEME.project, bold: true },
+      item: { fg: THEME.text, bg: THEME.bg },
     },
   });
 
@@ -95,11 +141,13 @@ async function runWorkbench() {
     keys: true,
     vi: false,
     tags: true,
-    scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'cyan' } },
+    scrollbar: { ch: ' ', track: { bg: THEME.surface }, style: { bg: THEME.accent } },
     style: {
-      border: { fg: 'cyan' },
-      selected: { fg: 'black', bg: 'cyan', bold: true },
-      item: { fg: 'white' },
+      bg: THEME.bg,
+      border: { fg: THEME.accent, bg: THEME.bg },
+      label: { fg: THEME.accent, bg: THEME.bg },
+      selected: { fg: THEME.textInverse, bg: THEME.accent, bold: true },
+      item: { fg: THEME.text, bg: THEME.bg },
     },
   });
 
@@ -117,10 +165,15 @@ async function runWorkbench() {
     keys: true,
     vi: true,
     alwaysScroll: true,
-    tags: false,
-    parseTags: false,
-    scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'cyan' } },
-    style: { border: { fg: 'cyan' }, fg: 'white' },
+    tags: true,
+    parseTags: true,
+    scrollbar: { ch: ' ', track: { bg: THEME.surface }, style: { bg: THEME.accent } },
+    style: {
+      bg: THEME.bg,
+      border: { fg: THEME.accent, bg: THEME.bg },
+      fg: THEME.text,
+      label: { fg: THEME.accent, bg: THEME.bg },
+    },
   });
 
   const status = blessed.box({
@@ -130,7 +183,7 @@ async function runWorkbench() {
     bottom: 0,
     height: 3,
     padding: { left: 1, right: 1 },
-    style: { fg: 'white', bg: 'black' },
+    style: { fg: THEME.text, bg: THEME.surface },
   });
 
   const prompt = blessed.prompt({
@@ -141,7 +194,12 @@ async function runWorkbench() {
     top: 'center',
     left: 'center',
     padding: { left: 1, right: 1 },
-    style: { border: { fg: 'yellow' }, fg: 'white', bg: 'black' },
+    style: {
+      border: { fg: THEME.warning, bg: THEME.surface },
+      fg: THEME.text,
+      bg: THEME.surface,
+      label: { fg: THEME.warning, bg: THEME.surface },
+    },
   });
 
   const question = blessed.question({
@@ -152,7 +210,12 @@ async function runWorkbench() {
     top: 'center',
     left: 'center',
     padding: { left: 1, right: 1 },
-    style: { border: { fg: 'red' }, fg: 'white', bg: 'black' },
+    style: {
+      border: { fg: THEME.danger, bg: THEME.surface },
+      fg: THEME.text,
+      bg: THEME.surface,
+      label: { fg: THEME.danger, bg: THEME.surface },
+    },
   });
 
   const backendPicker = blessed.list({
@@ -167,10 +230,13 @@ async function runWorkbench() {
     mouse: true,
     keys: true,
     vi: false,
+    tags: true,
     style: {
-      border: { fg: 'yellow' },
-      selected: { fg: 'black', bg: 'yellow', bold: true },
-      item: { fg: 'white' },
+      bg: THEME.bg,
+      border: { fg: THEME.warning, bg: THEME.bg },
+      label: { fg: THEME.warning, bg: THEME.bg },
+      selected: { fg: THEME.textInverse, bg: THEME.warning, bold: true },
+      item: { fg: THEME.text, bg: THEME.bg },
     },
   });
 
@@ -204,13 +270,35 @@ async function runWorkbench() {
     if (index !== -1) groupIndex = index;
   };
 
-  const currentSessions = () => {
+  const currentGroupSessions = () => {
     const group = currentGroup();
     if (group.kind === 'all') return sessions;
     if (group.kind === 'source') return sessionsForSource(group.source.id);
     return sessions.filter((session) => session.sourceId === group.source.id && session.cwd === group.cwd);
   };
 
+  const normalizedSearch = () => searchQuery.trim().toLowerCase();
+
+  const sessionMatchesSearch = (session) => {
+    const query = normalizedSearch();
+    if (!query) return true;
+    const haystack = [
+      session.backend,
+      session.cwd,
+      session.first,
+      session.id,
+      session.last,
+      session.lastAssistant,
+      session.name,
+      session.note,
+      session.provider,
+      session.sourceLabel,
+    ].filter(Boolean).join('\n').toLowerCase();
+    return haystack.includes(query);
+  };
+
+  const currentSessions = () => currentGroupSessions().filter(sessionMatchesSearch);
+
   const selectedSession = () => currentSessions()[selected] || null;
 
   const groupDisplayName = (group) => {
@@ -226,15 +314,9 @@ async function runWorkbench() {
 
   const styledListLabel = (color, text) => `{${color}-fg}{bold}${blessed.escape(text)}{/}`;
 
-  const backendThemes = {
-    codex: 'cyan',
-    pi: 'magenta',
-    opencode: 'green',
-  };
-
   const backendLabel = (backend, width = 0) => {
     const text = backend || 'unknown';
-    const color = backendThemes[text] || 'yellow';
+    const color = THEME.backend[text] || THEME.backend.unknown;
     return `{${color}-fg}{bold}${blessed.escape(text.padEnd(width))}{/}`;
   };
 
@@ -246,53 +328,58 @@ async function runWorkbench() {
     const width = Math.max(12, projectWidth - 4);
     const head = `= ${text} `;
     const line = `${head}${'='.repeat(width)}`.slice(0, width);
-    return styledListLabel('yellow', line);
+    return styledListLabel(THEME.tag.warning, line);
   };
 
   const projectLabel = (group) => {
-    if (group.kind === 'all') return styledListLabel('white', `0 All (${sessions.length})`);
+    if (group.kind === 'all') return styledListLabel(THEME.tag.text, `0 All (${sessions.length})`);
     if (group.kind === 'source') {
       const count = sessionsForSource(group.source.id).length;
       return machineLabel(group.source, count);
     }
     const count = sessions.filter((session) => session.sourceId === group.source.id && session.cwd === group.cwd).length;
     const base = path.basename(group.cwd) || group.cwd;
-    return `  ${blessed.escape(`${truncate(base, Math.max(10, projectWidth - 12))} (${count})`)}`;
+    return `{${THEME.tag.muted}-fg}  ${blessed.escape(`${truncate(base, Math.max(10, projectWidth - 12))} (${count})`)}{/}`;
   };
 
   const sessionLabel = (session) => {
     const title = session.name || session.first || session.last || '(no prompt)';
     const width = Math.max(24, (screen.width || 80) - projectWidth - 8);
-    const backendWidth = Math.max(8, Math.min(12, String(session.backend || 'unknown').length + 2));
+    const backendWidth = 11;
     const time = truncate(localTime(session.updatedAt), 18).padEnd(18);
     const detailWidth = Math.max(12, width - backendWidth - 22);
-    return `${backendLabel(session.backend, backendWidth)}  ${time}  ${blessed.escape(truncate(title, detailWidth))}`;
+    return `${backendLabel(session.backend, backendWidth)}  {${THEME.tag.muted}-fg}${blessed.escape(time)}{/}  ${blessed.escape(truncate(title, detailWidth))}`;
   };
 
   const detailContent = (session) => {
-    if (!session) return 'No sessions in this project.';
+    if (!session) return `{${THEME.tag.muted}-fg}No sessions match this view.{/}`;
     const title = session.name || session.first || session.last || '(no prompt)';
     return [
-      title,
+      `{${THEME.tag.accent}-fg}{bold}${blessed.escape(title)}{/}`,
+      '',
+      `{${THEME.tag.muted}-fg}Session{/}`,
+      `  backend  ${session.backend || 'unknown'}`,
+      `  id       ${session.id}`,
+      `  source   ${session.sourceLabel || 'Local'}`,
+      `  cwd      ${session.cwd}`,
       '',
-      `id:       ${session.id}`,
-      `backend:  ${session.backend || 'unknown'}`,
-      `source:   ${session.sourceLabel || 'Local'}`,
-      `cwd:      ${session.cwd}`,
-      `started:  ${localTime(session.startedAt)}`,
-      `updated:  ${localTime(session.updatedAt)}`,
-      `turns:    ${session.turns}`,
-      session.note ? `note:     ${session.note}` : '',
+      `{${THEME.tag.muted}-fg}Timeline{/}`,
+      `  started  ${localTime(session.startedAt)}`,
+      `  updated  ${localTime(session.updatedAt)}`,
+      `  turns    ${session.turns}`,
+      session.note ? `\n{${THEME.tag.muted}-fg}Note{/}\n  ${session.note}` : '',
       '',
-      `last user:      ${session.last || session.first || ''}`,
+      `{${THEME.tag.muted}-fg}Last user{/}`,
+      `${session.last || session.first || ''}`,
       '',
-      `last assistant: ${session.lastAssistant || ''}`,
+      `{${THEME.tag.muted}-fg}Last assistant{/}`,
+      `${session.lastAssistant || ''}`,
     ].filter((line) => line !== '').join('\n');
   };
 
   const setMessage = (text, isError = false) => {
     message = text || 'Ready';
-    status.style.fg = isError ? 'red' : 'white';
+    status.style.fg = isError ? THEME.danger : THEME.text;
   };
 
   const visibleSession = (session) => !session.archived;
@@ -428,7 +515,9 @@ async function runWorkbench() {
   const syncList = () => {
     const visible = currentSessions();
     const listRows = Math.max(1, (sessionsList.height || Math.floor((screen.height || 24) * 0.4)) - 2);
-    const items = visible.length ? visible.map(sessionLabel) : ['No sessions in this project.'];
+    const items = visible.length
+      ? visible.map(sessionLabel)
+      : [`{${THEME.tag.muted}-fg}${searchQuery ? 'No sessions match this search.' : 'No sessions in this project.'}{/}`];
     while (items.length < listRows) items.push('');
     syncingList = true;
     sessionsList.clearItems();
@@ -444,8 +533,8 @@ async function runWorkbench() {
   const setPanelLabel = (panel, title, focused, fg) => {
     panel.setLabel(focused ? ` > ${title} ` : `   ${title} `);
     if (!panel._label) return;
-    panel._label.style.fg = focused ? fg : 'white';
-    panel._label.style.bg = 'default';
+    panel._label.style.fg = focused ? fg : THEME.textMuted;
+    panel._label.style.bg = THEME.bg;
     panel._label.style.bold = focused;
   };
 
@@ -454,33 +543,39 @@ async function runWorkbench() {
     const sessionsFocused = activePanel === 'sessions';
     const detailFocused = activePanel === 'details';
 
-    projectsList.style.border.fg = projectFocused ? 'green' : 'gray';
-    sessionsList.style.border.fg = sessionsFocused ? 'cyan' : 'gray';
-    detailBox.style.border.fg = detailFocused ? 'yellow' : 'gray';
-    projectsList.style.selected.bg = projectFocused ? 'green' : 'gray';
-    projectsList.style.selected.fg = 'black';
-    sessionsList.style.selected.bg = sessionsFocused ? 'cyan' : 'gray';
-    sessionsList.style.selected.fg = 'black';
-
-    setPanelLabel(projectsList, `Sources (${sources.length})`, projectFocused, 'green');
-    setPanelLabel(sessionsList, 'Sessions', sessionsFocused, 'cyan');
-    setPanelLabel(detailBox, 'Details', detailFocused, 'yellow');
+    projectsList.style.border.fg = projectFocused ? THEME.project : THEME.borderIdle;
+    projectsList.style.border.bg = THEME.bg;
+    sessionsList.style.border.fg = sessionsFocused ? THEME.accent : THEME.borderIdle;
+    sessionsList.style.border.bg = THEME.bg;
+    detailBox.style.border.fg = detailFocused ? THEME.detail : THEME.borderIdle;
+    detailBox.style.border.bg = THEME.bg;
+    projectsList.style.selected.bg = projectFocused ? THEME.project : THEME.surfaceMuted;
+    projectsList.style.selected.fg = THEME.textInverse;
+    sessionsList.style.selected.bg = sessionsFocused ? THEME.accent : THEME.surfaceMuted;
+    sessionsList.style.selected.fg = THEME.textInverse;
+
+    setPanelLabel(projectsList, `Sources (${sources.length})`, projectFocused, THEME.project);
+    setPanelLabel(sessionsList, searchQuery ? `Sessions / ${searchQuery}` : 'Sessions', sessionsFocused, THEME.accent);
+    setPanelLabel(detailBox, 'Details', detailFocused, THEME.detail);
 
     const firstLine = message || 'Ready';
+    const searchHelp = searchQuery ? `  search "${searchQuery}"  x clear` : '  / search';
     if (projectFocused) {
-      status.setContent(`${firstLine}\nSources: ↑/↓ select  0 all  1-9 machine  [/] prev/next  n new  → sessions  q quit`);
+      status.setContent(`${firstLine}\nSources: ↑/↓ select  0 all  1-9 machine  [/] prev/next  n new${searchHelp}  → sessions  q quit`);
     } else if (detailFocused) {
-      status.setContent(`${firstLine}\nDetails: ↑/↓ scroll  1-9 machine  [/] prev/next  n new  ← sessions  q quit`);
+      status.setContent(`${firstLine}\nDetails: ↑/↓ scroll  1-9 machine  [/] prev/next  n new${searchHelp}  ← sessions  q quit`);
     } else {
-      status.setContent(`${firstLine}\nSessions: ↑/↓ select  Enter resume  1-9 machine  [/] prev/next  r rename  n new  d delete`);
+      status.setContent(`${firstLine}\nSessions: ↑/↓ select  Enter resume  r rename  n new  d delete${searchHelp}  q quit`);
     }
   };
 
   const render = () => {
     applyLayout();
     const visible = currentSessions();
+    const groupTotal = currentGroupSessions().length;
     const updateText = updateInfo ? `  Update available: v${updateInfo.latestVersion}` : '';
-    header.setContent(` ${appTitle}${updateText}\n ${visible.length}/${sessions.length} visible  ${groupDisplayName(currentGroup())}`);
+    const searchText = searchQuery ? `  search: ${searchQuery}` : '';
+    header.setContent(` ${appTitle}${updateText}\n ${visible.length}/${groupTotal} shown  ${groupDisplayName(currentGroup())}${searchText}`);
     detailBox.setContent(detailContent(selectedSession()));
     updateFocusStyles();
     screen.render();
@@ -520,7 +615,10 @@ async function runWorkbench() {
 
     backendPickerState = { backends, resolve };
     backendPicker.clearItems();
-    backendPicker.setItems(backends.map((backend) => `${backend.id}  ${backend.label || backend.id}`));
+    backendPicker.setItems(backends.map((backend) => {
+      const id = String(backend.id);
+      return `${backendLabel(id, 11)}  ${blessed.escape(backend.label || id)}`;
+    }));
     backendPicker.select(0);
     backendPicker.show();
     backendPicker.setFront();
@@ -532,6 +630,7 @@ async function runWorkbench() {
     askInput,
     focusOnClose: () => focusPanel(projectsList, 'projects'),
     screen,
+    theme: THEME,
     truncate,
   });
 
@@ -831,6 +930,25 @@ async function runWorkbench() {
     switchSource(-1);
   });
 
+  screen.key(['/'], async () => {
+    if (promptOpen()) return;
+    const value = await askInput('Search', searchQuery);
+    if (value === null) return render();
+    searchQuery = value.trim();
+    selected = 0;
+    syncList();
+    render();
+  });
+
+  screen.key(['x'], () => {
+    if (promptOpen() || !searchQuery) return;
+    searchQuery = '';
+    selected = 0;
+    setMessage('Search cleared.');
+    syncList();
+    render();
+  });
+
   screen.key(['q', 'escape', 'C-c'], () => {
     if (promptOpen()) return;
     leaveScreen();