@bramblex/codex-workbench 0.1.18 → 0.1.20

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) and pi. 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.
 
@@ -131,12 +131,14 @@ Remote backends are supported as long as the remote `cwb` can read them.
 
 ## Backends
 
-codex-workbench auto-detects installed backends by checking their session directories.
+codex-workbench auto-detects installed backends by checking each backend's session storage.
 
 | 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. |
 
 Session metadata such as custom names, notes, and archive state is stored in workbench's own metadata file, not inside backend session files.
 
@@ -164,7 +166,9 @@ 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?"
 
 cwb dirs --cwd ~/projects
@@ -189,12 +193,18 @@ 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 |
+| `OPENCODE_DB` | `$OPENCODE_DATA_DIR/opencode.db` | opencode SQLite database |
 | `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 |
 
 By default, codex-workbench discovers the `codex` binary through your login shell's `PATH`. Set `CODEX_BIN` to override.
 
@@ -218,10 +228,18 @@ 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.
 
+### No opencode sessions found
+
+Make sure you've run opencode at least once. Sessions are stored in the SQLite database at `$OPENCODE_DB` or `$OPENCODE_DATA_DIR/opencode.db`. Run `opencode session list --format json` or `opencode db path` to verify.
+
 ### A backend is missing from doctor
 
 Backends appear only when their session directory exists. For a new backend integration, add a provider under `src/providers/` with session discovery, parsing, binary discovery, and command routing.
@@ -284,7 +302,9 @@ 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
   services/
     codex-runner.js          # backward-compatible provider runner wrapper

package/package.json

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

package/src/cli-output.js

@@ -31,9 +31,18 @@ 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
+  OPENCODE_DB           default: $OPENCODE_DATA_DIR/opencode.db
   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
 `);
 }
 
@@ -106,8 +115,13 @@ function printDoctor() {
       try { provider.resolveBin(); } catch (err) { console.log(`  error:    ${err.message}`); }
     }
     try {
-      const files = provider.getSessionFiles();
-      console.log(`  sessions: ${files.length} file${files.length === 1 ? '' : 's'}`);
+      if (provider.listSessions) {
+        const sessions = provider.listSessions();
+        console.log(`  sessions: ${sessions.length}`);
+      } else {
+        const files = provider.getSessionFiles();
+        console.log(`  sessions: ${files.length} file${files.length === 1 ? '' : 's'}`);
+      }
     } catch (err) {
       console.log(`  sessions: error - ${err.message}`);
     }

package/src/model/session-store.js

@@ -18,10 +18,10 @@ function listSessions() {
   const fileEntries = getAllSessionFiles();
 
   const sessions = [];
-  for (const { file, backend } of fileEntries) {
+  for (const { file, backend, session: listedSession } of fileEntries) {
     try {
       const provider = getProvider(backend);
-      const session = provider.parseSession(file);
+      const session = listedSession || provider.parseSession(file);
       // Merge workbench metadata (name, note, archived)
       const custom = meta.sessions[session.id] || {};
       sessions.push({ ...session, ...custom });
@@ -45,7 +45,7 @@ function resolveSession(query, sessions) {
     return session.id === query ||
       session.id.startsWith(query) ||
       session.name === query ||
-      path.basename(session.file) === query;
+      (session.file && path.basename(session.file) === query);
   });
   if (matches.length === 1) return matches[0];
   if (matches.length === 0) throw new Error(`No session matched: ${query}`);
@@ -55,6 +55,7 @@ function resolveSession(query, sessions) {
 }
 
 function deleteSessionFile(session) {
+  if (!session.file) throw new Error(`Session does not have a standalone file: ${session.id}`);
   fs.unlinkSync(session.file);
   removeMetadata(session);
 }

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,9 +5,11 @@
 // ---------------------------------------------------------------------------
 
 const codex = require('./codex');
+const claude = require('./claude');
+const opencode = require('./opencode');
 const pi = require('./pi');
 
-const ALL_PROVIDERS = [codex, pi];
+const ALL_PROVIDERS = [codex, pi, opencode, claude];
 const providerMap = new Map(ALL_PROVIDERS.map((p) => [p.id, p]));
 
 /**
@@ -41,6 +43,10 @@ function providerForSession(session) {
 function getAllSessionFiles() {
   const files = [];
   for (const provider of getAvailableProviders()) {
+    if (provider.listSessions) {
+      for (const session of provider.listSessions()) files.push({ session, backend: provider.id });
+      continue;
+    }
     for (const file of provider.getSessionFiles()) {
       files.push({ file, backend: provider.id });
     }
@@ -54,6 +60,8 @@ module.exports = {
   getProvider,
   providerForSession,
   getAllSessionFiles,
+  claude,
   codex,
+  opencode,
   pi,
 };

package/src/providers/opencode.js

@@ -0,0 +1,262 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { removeMetadata } = require('../model/metadata');
+
+const HOME = os.homedir();
+const OPENCODE_DATA_DIR = process.env.OPENCODE_DATA_DIR ||
+  path.join(process.env.XDG_DATA_HOME || path.join(HOME, '.local', 'share'), 'opencode');
+const OPENCODE_DB = process.env.OPENCODE_DB || path.join(OPENCODE_DATA_DIR, 'opencode.db');
+
+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 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;
+    throw new Error(`OPENCODE_BIN is not executable: ${process.env.OPENCODE_BIN}`);
+  }
+  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.');
+}
+
+function dbQuery(sql) {
+  const result = spawnSync(resolveOpenCodeBin(), ['db', sql, '--format', 'json'], {
+    encoding: 'utf8',
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error((result.stderr || '').trim() || `opencode db exited with code ${result.status}`);
+  return JSON.parse(result.stdout || '[]');
+}
+
+function sqlString(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function parseJson(value, fallback) {
+  try { return JSON.parse(value || ''); } catch { return fallback; }
+}
+
+function collectText(value, out = []) {
+  if (!value) return out;
+  if (typeof value === 'string') {
+    if (value.trim()) out.push(value.trim());
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectText(item, out);
+    return out;
+  }
+  if (typeof value === 'object') {
+    for (const key of ['text', 'content', 'prompt', 'message', 'title']) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) collectText(value[key], out);
+    }
+  }
+  return out;
+}
+
+function messageRole(row, data) {
+  const type = String(row.type || data.role || data.type || '').toLowerCase();
+  if (type.includes('user') || type.includes('input')) return 'user';
+  if (type.includes('assistant') || type.includes('agent')) return 'assistant';
+  return type || 'message';
+}
+
+function listMessages(sessionId) {
+  const rows = dbQuery(
+    `select type, data from session_message where session_id = ${sqlString(sessionId)} order by seq asc`
+  );
+  return rows.map((row) => {
+    const data = parseJson(row.data, {});
+    return {
+      role: messageRole(row, data),
+      text: collectText(data).join(' ').replace(/\s+/g, ' ').trim(),
+    };
+  }).filter((message) => message.text);
+}
+
+function firstUserText(messages) {
+  const message = messages.find((item) => item.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 millisToIso(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  return new Date(number).toISOString();
+}
+
+function sessionFromRow(row) {
+  const messages = listMessages(row.id);
+  const turns = messages.filter((message) => message.role === 'user').length;
+  return {
+    id: row.id,
+    file: '',
+    cwd: row.directory || '(unknown)',
+    startedAt: millisToIso(row.time_created),
+    updatedAt: millisToIso(row.time_updated),
+    cliVersion: row.version || '',
+    provider: row.model || '',
+    turns,
+    first: row.title || firstUserText(messages),
+    last: lastText(messages, 'user'),
+    lastAssistant: lastText(messages, 'assistant'),
+    messages,
+    archived: Boolean(row.time_archived),
+    backend: 'opencode',
+  };
+}
+
+function listSessions() {
+  const rows = dbQuery(
+    'select id, title, directory, version, model, time_created, time_updated, time_archived from session order by time_updated desc'
+  );
+  return rows.map(sessionFromRow);
+}
+
+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 runArgv(argv, cwd, inherit) {
+  if (inherit) {
+    const child = spawn(argv[0], argv.slice(1), { stdio: 'inherit', cwd, env: process.env });
+    child.on('error', (err) => { console.error(`error: failed to start opencode: ${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(argv[0], argv.slice(1), { stdio: 'inherit', cwd, env: process.env });
+  if (result.error) throw new Error(`failed to start opencode: ${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 = resolveOpenCodeBin();
+  const cwd = usableCwd(session.cwd);
+  switch (command) {
+    case 'resume':
+      {
+        const argv = [executable, cwd, '--session', session.id];
+        if (args && args.length) argv.push('--prompt', args.join(' '));
+        return runArgv(argv, cwd, inherit);
+      }
+    case 'fork':
+      return runArgv([executable, cwd, '--session', session.id, '--fork'], cwd, inherit);
+    case 'delete': {
+      const status = runArgv([executable, 'session', 'delete', session.id], cwd, false);
+      if (status === 0) removeMetadata(session);
+      return status;
+    }
+    case 'archive':
+      dbQuery(`update session set time_archived = ${Date.now()} where id = ${sqlString(session.id)}`);
+      return 0;
+    case 'unarchive':
+      dbQuery(`update session set time_archived = null where id = ${sqlString(session.id)}`);
+      return 0;
+    default:
+      throw new Error(`Unknown command for opencode backend: ${command}`);
+  }
+}
+
+function runNew(cwd, args, inherit) {
+  const resolvedCwd = usableCwd(cwd);
+  const argv = [resolveOpenCodeBin(), resolvedCwd];
+  if (args && args.length) argv.push('--prompt', args.join(' '));
+  return runArgv(argv, resolvedCwd, inherit);
+}
+
+function isAvailable() {
+  try {
+    resolveOpenCodeBin();
+    return fs.statSync(OPENCODE_DB).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function getSessionFiles() {
+  return [];
+}
+
+function resolveBin() {
+  try { return resolveOpenCodeBin(); } catch { return null; }
+}
+
+module.exports = {
+  id: 'opencode',
+  label: 'opencode',
+  capabilities: {
+    new: true,
+    resume: true,
+    fork: true,
+    archive: true,
+    unarchive: true,
+    delete: true,
+  },
+  isAvailable,
+  getSessionFiles,
+  listSessions,
+  resolveBin,
+  runCommand: runSessionCommand,
+  runNew,
+};

package/src/ui/workbench.js

@@ -94,6 +94,7 @@ async function runWorkbench() {
     mouse: true,
     keys: true,
     vi: false,
+    tags: true,
     scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'cyan' } },
     style: {
       border: { fg: 'cyan' },
@@ -225,6 +226,19 @@ async function runWorkbench() {
 
   const styledListLabel = (color, text) => `{${color}-fg}{bold}${blessed.escape(text)}{/}`;
 
+  const backendThemes = {
+    claude: 'yellow',
+    codex: 'cyan',
+    pi: 'magenta',
+    opencode: 'green',
+  };
+
+  const backendLabel = (backend, width = 0) => {
+    const text = backend || 'unknown';
+    const color = backendThemes[text] || 'yellow';
+    return `{${color}-fg}{bold}${blessed.escape(text.padEnd(width))}{/}`;
+  };
+
   const machineLabel = (source, count) => {
     const shortcut = sourceShortcut(source);
     const prefix = shortcut ? `${shortcut} ` : '';
@@ -248,14 +262,12 @@ async function runWorkbench() {
   };
 
   const sessionLabel = (session) => {
-    const flags = [
-      session.backend || '',
-      session.name ? 'renamed' : '',
-      session.note ? 'note' : '',
-    ].filter(Boolean).join(',');
     const title = session.name || session.first || session.last || '(no prompt)';
-    const flagText = flags ? `[${flags}]` : '';
-    return `${shortId(session.id)}  ${String(session.turns).padStart(2)}t  ${truncate(localTime(session.updatedAt), 18)}  ${flagText} ${truncate(title, 88)}`;
+    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 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))}`;
   };
 
   const detailContent = (session) => {