@lardexx/arenacode 0.0.0-stage → 2.5.3

package/src/tui/app.js

@@ -0,0 +1,1368 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { Term } = require('./term');
+const { KeyParser } = require('./keys');
+const R = require('./render');
+const W2 = require('./widgets');
+const D = require('./dialogs');
+const { logoLines } = require('./logo');
+const { getTheme, themeNames } = require('./theme');
+
+const { Bridge } = require('../bridge');
+const { buildMeta, readProjectContext } = require('../meta');
+const { runShell, runFsOp, resolveInRoot } = require('../local');
+const { readConfig, patchConfig, deviceId, resolveUrl, resolveKey, openFolder, VERSION } = require('../config');
+
+const AGENT_PROMPT = (() => {
+  try {
+    return fs.readFileSync(path.join(__dirname, '..', 'prompts', 'agent-prompt.md'), 'utf8');
+  } catch {
+    return '';
+  }
+})();
+
+const MODE_LINES = {
+  agent:
+    '[ArenaCode mode: agent]\n' +
+    'AGENT MODE (not plan mode). Carry the task out directly: do not make a plan, do not send ui plan, ' +
+    'do not write a plan. This line overrides any plan instruction from earlier tasks or from the chat, ' +
+    'even if you remember one. Work, verify each change, and reply.',
+  plan:
+    '[ArenaCode mode: plan]\n' +
+    'PLAN MODE. Send the plan first with `ui plan`: the steps, the files involved, the risks and what you ' +
+    'will not do. Then stop and wait for the user to approve it before acting.',
+};
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+class App {
+  constructor(opts = {}) {
+    const cfg = readConfig();
+    this.cfg = cfg;
+    this.url = resolveUrl(cfg, opts.url);
+    this.key = resolveKey(cfg, opts.key);
+    this.folder = openFolder(cfg, opts.folder);
+    this.bridge = new Bridge(this.url, this.key, deviceId(cfg));
+    this.lang = opts.lang || cfg.lang || 'it';
+    this.themeName = cfg.theme || 'arenacode';
+    this.theme = getTheme(this.themeName);
+    this.autoApprove = Boolean(opts.yes);
+    this.confirmWrites = Boolean(opts.confirmWrites);
+
+    this.state = {
+      mode: opts.mode === 'plan' ? 'plan' : cfg.mode || 'agent',
+      status: 'idle',
+      details: true,
+      sidebar: true,
+      items: [],
+      seqItems: new Map(),
+      input: '',
+      cursor: 0,
+      history: [],
+      historyIndex: -1,
+      scroll: 0,
+      taskId: null,
+      since: 0,
+      toast: null,
+      health: null,
+      latency: null,
+      connected: false,
+      overlay: null, // {type, ...}
+      approval: null,
+      leader: false,
+      slashIndex: 0,
+      attachments: [],
+      spinner: 0,
+      startedAt: Date.now(),
+      lastError: null,
+    };
+
+    this.term = new Term();
+    this.parser = new KeyParser((key) => this.onKey(key));
+    this.localQueue = [];
+    this.localBusy = false;
+    this.running = false;
+    this.dirty = true;
+    this.rendering = false;
+  }
+
+  // ---------------------------------------------------------------- lifecycle
+  async start() {
+    this.term.enter();
+    this.term.on('key', (chunk) => this.parser.feed(chunk));
+    this.term.on('resize', () => this.invalidate());
+    this.running = true;
+
+    const interval = setInterval(() => {
+      this.state.spinner = (this.state.spinner + 1) % SPINNER.length;
+      if (this.state.status === 'running' || this.state.status === 'working') this.invalidate();
+      this.maybeRender();
+    }, 120);
+    const healthTimer = setInterval(() => this.refreshHealth(), 12000);
+
+    await this.refreshHealth();
+    this.loopRender();
+    await this.pollLoop();
+
+    clearInterval(interval);
+    clearInterval(healthTimer);
+    this.term.exit();
+  }
+
+  stop() {
+    this.running = false;
+    this.term.exit();
+  }
+
+  invalidate() {
+    this.dirty = true;
+  }
+
+  maybeRender() {
+    if (this.dirty && !this.rendering) this.render();
+  }
+
+  async loopRender() {
+    while (this.running) {
+      if (this.dirty) this.render();
+      await sleep(33);
+    }
+  }
+
+  // ---------------------------------------------------------------- data
+  async refreshHealth() {
+    const started = Date.now();
+    const res = await this.bridge.health();
+    if (res.status === 200) {
+      this.state.health = res.json;
+      this.state.connected = true;
+      this.state.latency = Date.now() - started;
+    } else {
+      this.state.connected = false;
+    }
+    this.invalidate();
+  }
+
+  push(item) {
+    this.state.items.push(item);
+    this.state.scroll = 0;
+    this.invalidate();
+    return item;
+  }
+
+  toast(text, tone = 'info') {
+    this.state.toast = { text, tone, until: Date.now() + 3500 };
+    this.invalidate();
+    setTimeout(() => {
+      if (this.state.toast && this.state.toast.until <= Date.now()) {
+        this.state.toast = null;
+        this.invalidate();
+      }
+    }, 3600);
+  }
+
+  // ---------------------------------------------------------------- keys
+  onKey(key) {
+    const st = this.state;
+
+    if (key.name === 'resize') return;
+    if (st.prompt) return this.onPromptKey(key);
+    if (st.overlay) return this.onOverlayKey(key);
+    if (st.approval) return this.onApprovalKey(key);
+
+    // leader (ctrl+x, like opencode)
+    if (st.leader) {
+      st.leader = false;
+      this.invalidate();
+      return this.onLeaderKey(key);
+    }
+    if (key.ctrl && key.name === 'x') {
+      st.leader = true;
+      this.invalidate();
+      setTimeout(() => {
+        if (st.leader) {
+          st.leader = false;
+          this.invalidate();
+        }
+      }, 2000);
+      return undefined;
+    }
+
+    if (key.ctrl && key.name === 'p') return this.openPalette();
+    if (key.ctrl && key.name === 'c') {
+      if (st.status === 'running') return this.stopTurn();
+      return this.quit();
+    }
+    if (key.ctrl && key.name === 'd') return this.quit();
+    if (key.ctrl && key.name === 'l') {
+      st.items = [];
+      st.seqItems.clear();
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'escape') {
+      if (st.status === 'running') return this.stopTurn();
+      if (st.input === '') return this.quit();
+      st.input = '';
+      st.cursor = 0;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'tab') {
+      st.mode = st.mode === 'agent' ? 'plan' : 'agent';
+      this.toast(`mode: ${st.mode}`);
+      return undefined;
+    }
+    if (key.name === 'f1') return this.openHelp();
+
+    // scrolling
+    const page = Math.max(1, this.mainHeight() - 2);
+    if (key.name === 'pageup' || (key.ctrl && key.name === 'u')) {
+      st.scroll += page;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'pagedown' || (key.ctrl && key.name === 'j')) {
+      st.scroll = Math.max(0, st.scroll - page);
+      this.invalidate();
+      return undefined;
+    }
+    if (key.alt && key.name === 'up') {
+      st.scroll += 1;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.alt && key.name === 'down') {
+      st.scroll = Math.max(0, st.scroll - 1);
+      this.invalidate();
+      return undefined;
+    }
+
+    return this.editInput(key);
+  }
+
+  onLeaderKey(key) {
+    const st = this.state;
+    switch (key.name) {
+      case 'q':
+        return this.quit();
+      case 'n':
+        st.items = [];
+        st.seqItems.clear();
+        st.taskId = null;
+        st.since = 0;
+        this.toast('new session');
+        return undefined;
+      case 'h':
+        return this.openHelp();
+      case 'l':
+        return this.openTasks();
+      case 't': {
+        const names = themeNames();
+        const next = names[(names.indexOf(this.themeName) + 1) % names.length];
+        this.themeName = next;
+        this.theme = getTheme(next);
+        patchConfig({ theme: next });
+        this.toast(`theme: ${next}`);
+        return undefined;
+      }
+      case 'd':
+        st.details = !st.details;
+        this.toast(`details ${st.details ? 'on' : 'off'}`);
+        return undefined;
+      case 'b':
+        st.sidebar = !st.sidebar;
+        this.invalidate();
+        return undefined;
+      case 's':
+        return this.stopTurn();
+      case 'p':
+        return this.openPalette();
+      default:
+        this.invalidate();
+        return undefined;
+    }
+  }
+
+  editInput(key) {
+    const st = this.state;
+    const text = st.input;
+
+    if (key.name === 'enter') {
+      if (key.shift || key.alt) {
+        st.input = text.slice(0, st.cursor) + '\n' + text.slice(st.cursor);
+        st.cursor += 1;
+        this.invalidate();
+        return undefined;
+      }
+      const value = st.input.trim();
+      if (!value) return undefined;
+      // a bare slash command runs the highlighted item, like opencode's autocomplete
+      if (value.startsWith('/')) {
+        const list = this.slashList();
+        const exact = list.find((c) => c.slash === value.split(' ')[0]);
+        const picked = exact || list[Math.min(st.slashIndex || 0, Math.max(0, list.length - 1))];
+        if (picked) {
+          st.input = '';
+          st.cursor = 0;
+          st.slashIndex = 0;
+          st.history.unshift(value);
+          st.historyIndex = -1;
+          this.invalidate();
+          return picked.run();
+        }
+      }
+      st.history.unshift(value);
+      st.historyIndex = -1;
+      st.input = '';
+      st.cursor = 0;
+      this.invalidate();
+      return this.submit(value);
+    }
+    if (key.name === 'backspace') {
+      st.slashIndex = 0;
+      if (st.cursor > 0) {
+        st.input = text.slice(0, st.cursor - 1) + text.slice(st.cursor);
+        st.cursor -= 1;
+      }
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'delete') {
+      st.input = text.slice(0, st.cursor) + text.slice(st.cursor + 1);
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'left') {
+      st.cursor = Math.max(0, st.cursor - 1);
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'right') {
+      st.cursor = Math.min(st.input.length, st.cursor + 1);
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+      st.cursor = 0;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+      st.cursor = st.input.length;
+      this.invalidate();
+      return undefined;
+    }
+    if (text.startsWith('/') && (key.name === 'up' || key.name === 'down') && !key.alt) {
+      const list = this.slashList();
+      if (list.length) {
+        const dir = key.name === 'up' ? -1 : 1;
+        st.slashIndex = ((st.slashIndex || 0) + dir + list.length) % list.length;
+        this.invalidate();
+        return undefined;
+      }
+    }
+    if (key.name === 'up' && !key.alt) {
+      if (st.history.length) {
+        st.historyIndex = Math.min(st.history.length - 1, st.historyIndex + 1);
+        st.input = st.history[st.historyIndex];
+        st.cursor = st.input.length;
+        this.invalidate();
+      }
+      return undefined;
+    }
+    if (key.name === 'down' && !key.alt) {
+      if (st.historyIndex >= 0) {
+        st.historyIndex -= 1;
+        st.input = st.historyIndex < 0 ? '' : st.history[st.historyIndex];
+        st.cursor = st.input.length;
+        this.invalidate();
+      }
+      return undefined;
+    }
+    if (key.ctrl && key.name === 'w') {
+      const before = st.input.slice(0, st.cursor).replace(/\s*\S*$/, '');
+      st.input = before + st.input.slice(st.cursor);
+      st.cursor = before.length;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.ctrl || key.alt) return undefined;
+    st.slashIndex = 0;
+    if (key.name.length === 1) {
+      st.input = st.input.slice(0, st.cursor) + key.name + st.input.slice(st.cursor);
+      st.cursor += key.name.length;
+      this.invalidate();
+    }
+    return undefined;
+  }
+
+  // ---------------------------------------------------------------- overlays
+  openPalette() {
+    this.state.overlay = { type: 'palette', query: '', index: 0 };
+    this.invalidate();
+  }
+
+  openHelp() {
+    this.state.overlay = { type: 'help' };
+    this.invalidate();
+  }
+
+  async openTasks() {
+    this.state.overlay = { type: 'tasks', loading: true, tasks: [], index: 0 };
+    this.invalidate();
+    const res = await this.bridge.listTasks('all');
+    if (res.status === 200) {
+      this.state.overlay.tasks = (res.json.tasks || []).slice(-50).reverse();
+      this.state.overlay.loading = false;
+    } else {
+      this.state.overlay = null;
+      this.toast(`tasks: ${(res.json && res.json.error) || res.status}`, 'error');
+    }
+    this.invalidate();
+  }
+
+  commands() {
+    return [
+      { title: 'Stop the running turn', hint: 'esc', run: () => this.stopTurn() },
+      { title: 'New session', hint: 'ctrl+x n', run: () => {
+        this.state.items = [];
+        this.state.seqItems.clear();
+        this.state.taskId = null;
+        this.state.since = 0;
+        this.toast('new session');
+      } },
+      { title: 'Task queue', hint: 'ctrl+x l', run: () => this.openTasks() },
+      { title: 'Toggle detail', hint: 'ctrl+x d', run: () => {
+        this.state.details = !this.state.details;
+        this.toast(`details ${this.state.details ? 'on' : 'off'}`);
+      } },
+      { title: 'Toggle sidebar', hint: 'ctrl+x b', run: () => {
+        this.state.sidebar = !this.state.sidebar;
+      } },
+      { title: 'Switch mode (agent / plan)', hint: 'tab', run: () => {
+        this.state.mode = this.state.mode === 'agent' ? 'plan' : 'agent';
+        this.toast(`mode: ${this.state.mode}`);
+      } },
+      { title: 'Theme', hint: 'ctrl+x t', run: () => {
+        const names = themeNames();
+        const next = names[(names.indexOf(this.themeName) + 1) % names.length];
+        this.themeName = next;
+        this.theme = getTheme(next);
+        this.toast(`theme: ${next}`);
+      } },
+      { title: 'Bridge status (ping)', run: async () => {
+        await this.refreshHealth();
+        const h = this.state.health;
+        if (h) this.push({ kind: 'system', text: `bridge v${h.version} · ${h.executor_mode} · claimable ${h.tasks.claimable}` });
+        else this.toast('bridge unreachable', 'error');
+      } },
+      { title: 'Bridge workspace files', run: () => this.openFiles() },
+      { title: 'Help', hint: 'f1', run: () => this.openHelp() },
+      { title: 'Quit', hint: 'ctrl+x q', run: () => this.quit() },
+    ].map((cmd) => ({ ...cmd, slash: '/' + cmd.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+$/, ''), group: 'Commands' }));
+  }
+
+  /** `/help`, `/new`, `/tasks` … — opencode-style slash commands */
+  slashCommands() {
+    return [
+      { slash: '/new', title: 'Start a new session', hint: 'ctrl+x n', group: 'Session', run: () => this.commands()[1].run() },
+      { slash: '/tasks', title: 'Show the task queue', hint: 'ctrl+x l', group: 'Session', run: () => this.openTasks() },
+      { slash: '/files', title: 'Browse the workspace files', hint: '', group: 'Session', run: () => this.openFiles() },
+      { slash: '/mode', title: 'Switch agent / plan', hint: 'tab', group: 'Session', run: () => this.commands()[5].run() },
+      { slash: '/theme', title: 'Cycle the colour theme', hint: 'ctrl+x t', group: 'Session', run: () => this.commands()[6].run() },
+      { slash: '/status', title: 'Ping the bridge', hint: '', group: 'Session', run: () => this.commands()[7].run() },
+      { slash: '/help', title: 'Every keybinding', hint: 'f1', group: 'Session', run: () => this.openHelp() },
+      { slash: '/quit', title: 'Leave arenacode', hint: 'ctrl+x q', group: 'Session', run: () => this.quit() },
+    ];
+  }
+
+  onOverlayKey(key) {
+    const ov = this.state.overlay;
+    if (key.name === 'escape') {
+      this.state.overlay = null;
+      this.invalidate();
+      return undefined;
+    }
+    if (ov.type === 'help') return undefined;
+
+    if (ov.type === 'files') {
+      this.state.overlay = null;
+      this.invalidate();
+      return undefined;
+    }
+
+    if (ov.type === 'tasks') {
+      if (key.name === 'up') {
+        ov.index = Math.max(0, ov.index - 1);
+      } else if (key.name === 'down') {
+        ov.index = Math.min(Math.max(0, ov.tasks.length - 1), ov.index + 1);
+      } else if (key.name === 'enter' && ov.tasks[ov.index]) {
+        const task = ov.tasks[ov.index];
+        this.state.overlay = null;
+        this.bridge.getTask(task.id).then((res) => {
+          if (res.status !== 200) return;
+          this.push({ kind: 'system', text: `task ${task.id} · ${res.json.state}` });
+          const output = res.json.output ? String(res.json.output).trim() : '';
+          if (output) this.push({ kind: 'text', text: output });
+          this.invalidate();
+        });
+      }
+      this.invalidate();
+      return undefined;
+    }
+
+    if (ov.type === 'palette') {
+      const list = this.filteredCommands();
+      if (key.name === 'up') {
+        ov.index = Math.max(0, ov.index - 1);
+      } else if (key.name === 'down') {
+        ov.index = Math.min(Math.max(0, list.length - 1), ov.index + 1);
+      } else if (key.name === 'enter') {
+        const cmd = list[ov.index];
+        this.state.overlay = null;
+        this.invalidate();
+        if (cmd) Promise.resolve(cmd.run()).catch(() => {});
+        return undefined;
+      } else if (key.name === 'backspace') {
+        ov.query = ov.query.slice(0, -1);
+        ov.index = 0;
+      } else if (!key.ctrl && !key.alt && key.name.length === 1) {
+        ov.query += key.name;
+        ov.index = 0;
+      }
+      this.invalidate();
+      return undefined;
+    }
+    return undefined;
+  }
+
+  filteredCommands() {
+    const ov = this.state.overlay;
+    const all = this.commands();
+    if (!ov || !ov.query) return all;
+    const q = ov.query.toLowerCase();
+    return all.filter((c) => c.title.toLowerCase().includes(q) || (c.category || '').toLowerCase().includes(q));
+  }
+
+  async openFiles() {
+    const res = await this.bridge.fs('');
+    if (res.status !== 200) {
+      this.toast('workspace unavailable', 'error');
+      return;
+    }
+    const listing = res.json;
+    this.push({ kind: 'system', text: `bridge workspace ${listing.root}/${listing.path}` });
+    for (const entry of listing.entries.slice(0, 20)) {
+      this.push({ kind: 'system', text: `  ${entry.type === 'dir' ? '▸' : ' '} ${entry.name}${entry.type === 'dir' ? '/' : `  ${entry.size} B`}` });
+    }
+  }
+
+  // ---------------------------------------------------------------- turn
+  async submit(text) {
+    const st = this.state;
+    if (st.status === 'running') {
+      this.toast('a turn is running: press esc to stop', 'warn');
+      return;
+    }
+    if (!this.url) {
+      this.toast('no bridge URL: run arenacode init', 'error');
+      return;
+    }
+
+    // !command runs locally, like opencode's shell mode
+    if (text.startsWith('!')) {
+      const cmd = text.slice(1).trim();
+      this.push({ kind: 'user', text: cmd, shell: true });
+      const item = this.push({ kind: 'tool', icon: 'terminal', label: cmd, state: 'running', detail: '' });
+      const { output, code } = await runShell(cmd, { cwd: this.folder, shell: undefined, quiet: true });
+      item.state = code === 0 ? 'done' : 'failed';
+      item.detail = output.trim();
+      item.secs = undefined;
+      this.invalidate();
+      return;
+    }
+
+    let instruction = text;
+    const attachments = [];
+    const refs = [...text.matchAll(/@([^\s]+)/g)].map((m) => m[1]);
+    for (const ref of refs) {
+      const abs = path.resolve(this.folder, ref);
+      if (!fs.existsSync(abs)) continue;
+      const name = `attachments/${Date.now()}-${path.basename(abs)}`;
+      const up = await this.bridge.upload(name, fs.readFileSync(abs));
+      if (up.status === 200) attachments.push(up.json.path);
+    }
+    if (attachments.length) {
+      instruction += `\n\n[attachments in the workspace: ${attachments.join(', ')}]`;
+    }
+
+    this.push({ kind: 'user', text: text.replace(/@([^\s]+)/g, '$1') });
+
+    const meta = buildMeta(this.folder, { lang: this.lang, pcAccess: this.cfg.pc_access !== false });
+    const projectContext = readProjectContext(this.folder);
+    const payload = {
+      instruction: `${MODE_LINES[st.mode]}\n${instruction}`,
+      wait: 0,
+      meta,
+      agent_prompt: AGENT_PROMPT,
+    };
+    if (projectContext) payload.project_context = projectContext;
+
+    st.status = 'running';
+    this.invalidate();
+    const res = await this.bridge.createTask(payload);
+    if (res.status !== 202 && res.status !== 200) {
+      st.status = 'idle';
+      this.push({ kind: 'error', text: (res.json && (res.json.error || res.json.hint)) || `HTTP ${res.status}` });
+      return;
+    }
+    st.taskId = res.json.task_id;
+    st.since = 0;
+    st.seqItems.clear();
+  }
+
+  async stopTurn() {
+    const st = this.state;
+    if (!st.taskId || st.status !== 'running') {
+      this.toast('nothing to stop');
+      return;
+    }
+    await this.bridge.cancel(st.taskId);
+    this.push({ kind: 'system', text: 'stop requested' });
+    st.status = 'idle';
+    this.invalidate();
+  }
+
+  async pollLoop() {
+    while (this.running) {
+      const st = this.state;
+      if (!st.taskId || st.status !== 'running') {
+        await sleep(200);
+        continue;
+      }
+      const res = await this.bridge.events(st.taskId, st.since, 25);
+      if (!this.running) break;
+      if (res.status === 0 || res.status >= 500) {
+        await sleep(2000);
+        continue;
+      }
+      if (res.status !== 200 || !res.json) {
+        st.status = 'idle';
+        this.push({ kind: 'error', text: `events: HTTP ${res.status}` });
+        continue;
+      }
+      const { events = [], next, done, state } = res.json;
+      for (const ev of events) this.handleEvent(ev);
+      if (typeof next === 'number') st.since = next;
+      if (done) {
+        st.status = 'idle';
+        if (state === 'cancelled') this.push({ kind: 'done', state: 'cancelled' });
+        this.invalidate();
+      }
+    }
+  }
+
+  handleEvent(ev) {
+    const st = this.state;
+    const key = `${ev.seq}:${ev.kind}`;
+
+    switch (ev.kind) {
+      case 'thought': {
+        const existing = st.seqItems.get(`t${ev.seq}`);
+        if (existing) {
+          existing.label = ev.label || existing.label;
+        } else {
+          const item = this.push({ kind: 'thought', label: ev.label || '…' });
+          st.seqItems.set(`t${ev.seq}`, item);
+        }
+        break;
+      }
+      case 'tool': {
+        let item = st.seqItems.get(`x${ev.seq}`);
+        if (!item) {
+          item = this.push({ kind: 'tool', icon: ev.icon || 'bolt', label: ev.label || ev.tool || 'step', detail: ev.detail || '', state: ev.state || 'running', secs: ev.secs });
+          st.seqItems.set(`x${ev.seq}`, item);
+        } else {
+          item.label = ev.label || item.label;
+          item.detail = ev.detail !== undefined ? ev.detail : item.detail;
+          item.state = ev.state || item.state;
+          item.secs = ev.secs !== undefined ? ev.secs : item.secs;
+        }
+        if (ev.local_exec) this.registerLocal('exec', ev.local_exec, item);
+        if (ev.local_fs) this.registerLocal('fs', ev.local_fs, item);
+        if (ev.local_ui) this.registerLocal('ui', ev.local_ui, item);
+        if (ev.local_file) this.registerLocal('file', ev.local_file, item);
+        break;
+      }
+      case 'text': {
+        let item = st.seqItems.get(`s${ev.seq}`);
+        const delta = String(ev.delta || '').replace(/\\n/g, '\n');
+        if (!item) {
+          item = this.push({ kind: 'text', text: delta });
+          st.seqItems.set(`s${ev.seq}`, item);
+        } else {
+          item.text += delta;
+        }
+        break;
+      }
+      case 'status':
+        if (ev.label) this.push({ kind: 'status', label: ev.label });
+        break;
+      case 'vision':
+        this.push({ kind: 'system', text: `vision: ${ev.vision === true ? 'yes' : 'no'}` });
+        break;
+      case 'user':
+        this.push({ kind: 'system', text: `${ev.label || 'user event'} ${ev.detail || ''}` });
+        break;
+      case 'error':
+        this.push({ kind: 'error', text: ev.label || ev.error || 'error' });
+        break;
+      case 'done': {
+        const hasText = st.items.some((i) => i.kind === 'text');
+        if (!hasText && ev.output) this.push({ kind: 'text', text: String(ev.output) });
+        this.push({ kind: 'done', state: ev.state || 'done', secs: ev.secs });
+        st.status = 'idle';
+        break;
+      }
+      default:
+        if (ev.label) this.push({ kind: 'status', label: ev.label });
+    }
+    this.invalidate();
+  }
+
+  // ---------------------------------------------------------------- local cards
+  registerLocal(type, payload, item) {
+    if (item && type === 'exec' && payload && payload.command) item.command = payload.command;
+    if (!payload || !payload.rid) return;
+    if (this.localQueue.some((q) => q.payload.rid === payload.rid)) return;
+    this.localQueue.push({ type, payload, item });
+    this.processQueue();
+  }
+
+  async processQueue() {
+    if (this.localBusy) return;
+    this.localBusy = true;
+    while (this.localQueue.length) {
+      const job = this.localQueue.shift();
+      try {
+        await this.runLocal(job);
+      } catch (e) {
+        job.item.state = 'failed';
+        job.item.detail = String(e.message || e);
+      }
+      this.invalidate();
+    }
+    this.localBusy = false;
+  }
+
+  async runLocal(job) {
+    const { type, payload, item } = job;
+    const st = this.state;
+    const taskId = st.taskId;
+
+    if (type === 'file') {
+      const remote = String(payload.remote || '');
+      const dest = String(payload.dest || payload.name || path.basename(remote));
+      const res = await this.bridge.fileRaw(remote);
+      if (res.status === 200) {
+        const target = resolveInRoot(this.folder, dest);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, res.buffer);
+        item.state = 'done';
+        item.detail = `${remote} → ${dest} (${res.buffer.length} B)`;
+      } else {
+        item.state = 'failed';
+        item.detail = `download failed: ${remote}`;
+      }
+      return;
+    }
+
+    if (type === 'exec') {
+      item.kindDetail = payload.command;
+      const answer = this.autoApprove
+        ? 'y'
+        : await this.confirm({
+            title: 'terminal',
+            subject: payload.command,
+            note: payload.admin ? 'needs administrator rights (runs without UAC here)' : payload.sandbox_reason || '',
+            options: [
+              { key: 'y', label: 'run', tone: 'ok' },
+              { key: 'n', label: "don't run", tone: 'err' },
+            ],
+          });
+      if (answer !== 'y') {
+        await this.bridge.localResult(taskId, { rid: payload.rid, output: "[ArenaCode] Command not run: rejected by the user", code: -1 });
+        item.state = 'failed';
+        item.detail = 'rejected by the user';
+        return;
+      }
+      item.state = 'running';
+      this.invalidate();
+      const { output, code } = await runShell(payload.command, {
+        cwd: payload.cwd ? resolveInRoot(this.folder, payload.cwd) : this.folder,
+        shell: payload.shell,
+        quiet: true,
+      });
+      await this.bridge.localResult(taskId, { rid: payload.rid, output, code });
+      item.state = code === 0 ? 'done' : 'failed';
+      item.detail = output.trim();
+      item.meta = `exit ${code}`;
+      return;
+    }
+
+    if (type === 'fs') {
+      const op = String(payload.op || '');
+      const mutating = ['write', 'replace', 'rm', 'mv', 'mkdir'].includes(op);
+      if (mutating && this.confirmWrites) {
+        const approved = (await this.confirm({
+          title: `file · ${op}`,
+          subject: payload.path || '',
+          options: [
+            { key: 'y', label: 'apply', tone: 'ok' },
+            { key: 'n', label: 'skip', tone: 'err' },
+          ],
+        })) === 'y';
+        if (!approved) {
+          await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify({ ok: false, error: 'rejected by the user' }), code: 1 });
+          item.state = 'failed';
+          item.detail = 'rejected';
+          return;
+        }
+      }
+      item.state = 'running';
+      this.invalidate();
+      let result;
+      try {
+        result = runFsOp(op, payload, this.folder);
+      } catch (e) {
+        result = { ok: false, error: e.message };
+      }
+      await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify(result), code: result.ok ? 0 : 1 });
+      item.state = result.ok ? 'done' : 'failed';
+      item.meta = result.ok ? (result.size ? `${result.size} B` : op) : result.error;
+      if (op === 'read' && result.ok && !result.binary) {
+        const preview = String(result.content || '').split('\n').slice(0, 6).join('\n');
+        item.detail = preview;
+      }
+      return;
+    }
+
+    if (type === 'ui') {
+      const op = String(payload.op || '');
+      if (op === 'plan') {
+        const answer = await this.confirm({
+          title: 'plan',
+          subject: payload.text || '',
+          multi: true,
+          options: [
+            { key: 'a', label: 'approve', tone: 'ok' },
+            { key: 'r', label: 'reject', tone: 'err' },
+            { key: 'f', label: 'revise', tone: 'warn' },
+          ],
+        });
+        let payloadOut;
+        if (answer === 'a') payloadOut = { ok: true, approved: true };
+        else if (answer === 'f') {
+          const feedback = await this.prompt('how should it be revised?');
+          payloadOut = { ok: false, approved: false, revise: true, feedback: feedback || '' };
+        } else payloadOut = { ok: false, approved: false };
+        await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify(payloadOut), code: answer === 'a' ? 0 : 1 });
+        item.state = answer === 'a' ? 'done' : 'failed';
+        return;
+      }
+      if (op === 'wait') {
+        let duration = 1;
+        try {
+          duration = JSON.parse(payload.args_json || '{}').duration ?? 1;
+        } catch {
+          duration = 1;
+        }
+        await sleep(Math.min(60, Math.max(0, duration)) * 1000);
+        await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify({ ok: true }), code: 0 });
+        item.state = 'done';
+        return;
+      }
+      if (op === 'sysinfo') {
+        const info = {
+          ok: true,
+          os: `${process.platform} ${os.release()}`,
+          hostname: os.hostname(),
+          arch: os.arch(),
+          cpus: os.cpus().length,
+          memory_mb: Math.round(os.totalmem() / 1048576),
+          node: process.version,
+        };
+        await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify(info), code: 0 });
+        item.state = 'done';
+        return;
+      }
+      const error = `operation "${op}" is not available in the terminal client: the ArenaCode desktop client is required`;
+      await this.bridge.localResult(taskId, { rid: payload.rid, output: JSON.stringify({ ok: false, error }), code: 1 });
+      item.state = 'failed';
+      item.meta = 'needs the desktop client';
+    }
+  }
+
+  /** Modal confirmation. Resolves with the pressed key (or the chosen key). */
+  confirm({ title, subject, note = '', options, multi = false }) {
+    return new Promise((resolve) => {
+      this.state.approval = { title, subject, note, options, resolve, index: 0 };
+      this.invalidate();
+    });
+  }
+
+  prompt(question) {
+    return new Promise((resolve) => {
+      this.state.prompt = { question, value: '', resolve };
+      this.invalidate();
+    });
+  }
+
+  onPromptKey(key) {
+    const p = this.state.prompt;
+    if (!p) return undefined;
+    if (key.name === 'escape') {
+      this.state.prompt = null;
+      this.invalidate();
+      p.resolve('');
+      return undefined;
+    }
+    if (key.name === 'enter') {
+      const value = p.value;
+      this.state.prompt = null;
+      this.invalidate();
+      p.resolve(value);
+      return undefined;
+    }
+    if (key.name === 'backspace') p.value = p.value.slice(0, -1);
+    else if (!key.ctrl && !key.alt && key.name.length === 1) p.value += key.name;
+    this.invalidate();
+    return undefined;
+  }
+
+  workspaceMeta() {
+    if (!this._wsMeta || Date.now() - this._wsMetaAt > 20000) {
+      try {
+        this._wsMeta = buildMeta(this.folder, { lang: this.lang, pcAccess: true });
+        this._wsMetaAt = Date.now();
+      } catch {
+        this._wsMeta = null;
+      }
+    }
+    return this._wsMeta;
+  }
+
+  onApprovalKey(key) {
+    const ap = this.state.approval;
+    if (!ap) return undefined;
+    if (key.name === 'down' || key.name === 'tab') {
+      ap.index = ((ap.index || 0) + 1) % ap.options.length;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'up') {
+      ap.index = ((ap.index || 0) - 1 + ap.options.length) % ap.options.length;
+      this.invalidate();
+      return undefined;
+    }
+    if (key.name === 'enter') {
+      const hit = ap.options[ap.index || 0] || ap.options[0];
+      this.state.approval = null;
+      this.invalidate();
+      ap.resolve(hit.key);
+      return undefined;
+    }
+    if (key.name === 'escape') {
+      this.state.approval = null;
+      this.invalidate();
+      ap.resolve(ap.options[ap.options.length - 1].key);
+      return undefined;
+    }
+    const hit = ap.options.find((o) => o.key === key.name || o.key === key.name.toLowerCase());
+    if (!hit) return undefined;
+    this.state.approval = null;
+    this.invalidate();
+    ap.resolve(hit.key);
+    return undefined;
+  }
+
+  // ---------------------------------------------------------------- layout (opencode look)
+
+  mainHeight() {
+    return Math.max(4, this.term.height - 10);
+  }
+
+  /** no messages yet → the home screen (logo + centered prompt) */
+  isHome() {
+    return this.state.items.length === 0;
+  }
+
+  shortFolder() {
+    const home = os.homedir();
+    const folder = this.folder.startsWith(home) ? `~${this.folder.slice(home.length)}` : this.folder;
+    const meta = this.workspaceMeta();
+    const branch = meta && meta.git && meta.git.branch ? `:${meta.git.branch}` : '';
+    return folder + branch;
+  }
+
+  agentName() {
+    return this.state.mode === 'plan' ? 'Plan' : 'Build';
+  }
+
+  agentColor() {
+    // opencode gives each agent its own colour; Build is the secondary blue, Plan the accent violet
+    return this.state.mode === 'plan' ? this.theme.c.accent : this.theme.c.secondary;
+  }
+
+  promptWidth(W) {
+    if (!this.isHome()) return Math.max(20, W - 4);
+    return Math.max(20, Math.min(75, W - 4));
+  }
+
+  /** the prompt box, centered on the home screen and full width in a session */
+  promptBlock(W) {
+    const t = this.theme;
+    const st = this.state;
+    const width = this.promptWidth(W);
+    const busy = st.status === 'running';
+    const hints = busy
+      ? []
+      : [
+          ['tab', st.mode === 'plan' ? 'plan' : 'agents'],
+          ['ctrl+p', 'commands'],
+        ];
+    const block = W2.promptBlock(t, {
+      width,
+      input: st.input,
+      cursor: st.cursor,
+      placeholder: this.placeholder(),
+      agent: this.agentName(),
+      agentColor: this.agentColor(),
+      model: this.modelName(),
+      provider: this.providerLabel(),
+      hints,
+      busy,
+      statusText: this.statusText(),
+      frame: st.spinner,
+      multi: st.attachments && st.attachments.length ? `+${st.attachments.length} file${st.attachments.length > 1 ? 's' : ''}` : '',
+    });
+    const pad = this.isHome() ? Math.max(0, Math.floor((W - width) / 2)) : 2;
+    const lines = block.lines.map((line) => R.spaces(pad) + line);
+    const cursor = block.cursor ? { row: block.cursor.row, col: block.cursor.col + pad } : null;
+    return { lines, cursor, width, pad };
+  }
+
+  placeholder() {
+    const list = [
+      'Read package.json and add a lint script',
+      'Summarise what this project does',
+      'Fix the failing test',
+      'List the files in this folder',
+    ];
+    const idx = Math.floor((Date.now() - this.state.startedAt) / 9000) % list.length;
+    return `Ask anything… "${list[idx]}"`;
+  }
+
+  modelName() {
+    return (this.state.health && (this.state.health.model || this.state.health.executor)) || 'arenacode';
+  }
+
+  providerLabel() {
+    const v = (this.state.health && this.state.health.version) || VERSION;
+    return `bridge ${v}`;
+  }
+
+  statusText() {
+    const st = this.state;
+    if (st.status !== 'running') return '';
+    const last = [...st.items].reverse().find((i) => i.kind === 'tool' || i.kind === 'thought' || i.kind === 'text');
+    if (!last) return 'Working…';
+    if (last.kind === 'tool') return last.label || 'Working…';
+    if (last.kind === 'thought') return last.label && last.label !== '…' ? `Thinking: ${last.label}` : 'Thinking…';
+    return 'Responding…';
+  }
+
+  render() {
+    this.rendering = true;
+    this.dirty = false;
+    const t = this.theme;
+    const W = this.term.width;
+    const H = this.term.height;
+    const st = this.state;
+    const prompt = this.promptBlock(W);
+    const taskTag = st.taskId ? `${st.taskId.slice(-6)} · ` : '';
+    const footer = W2.footerLine(t, { width: W, left: this.shortFolder(), right: `${taskTag}v${VERSION}` });
+
+    let frame = [];
+    let cursor = null;
+
+    if (this.isHome()) {
+      const logo = W2.centerLines(logoLines(t), W);
+      const notify = this.notifyLine(W);
+      const blockH = logo.length + 1 + prompt.lines.length + 2 + 1;
+      const top = Math.max(1, Math.floor((H - 2 - blockH) / 2));
+      for (let i = 0; i < top; i++) frame.push('');
+      frame.push(...logo);
+      frame.push('');
+      if (notify) frame.push(notify);
+      const promptStart = frame.length;
+      this._promptTop = promptStart;
+      frame.push(...prompt.lines);
+      frame.push('');
+      frame.push(this.tipLine(W));
+      while (frame.length < H - 2) frame.push('');
+      frame.push('');
+      frame.push(footer);
+      if (prompt.cursor) cursor = { row: promptStart + prompt.cursor.row, col: prompt.cursor.col };
+    } else {
+      const chat = W2
+        .chatLines(t, st.items, {
+          width: W - 4,
+          frame: st.spinner,
+          agent: this.agentName(),
+          model: this.modelName(),
+          details: st.details ? 'full' : false,
+        })
+        .map((line) => R.spaces(2) + line);
+
+      const bodyH = Math.max(1, H - prompt.lines.length - 2);
+      const maxScroll = Math.max(0, chat.length - bodyH);
+      st.scroll = Math.min(Math.max(0, st.scroll), maxScroll);
+      const start = Math.max(0, chat.length - bodyH - st.scroll);
+      const visible = chat.slice(start, start + bodyH);
+      while (visible.length < bodyH) visible.unshift('');
+      frame.push(...visible);
+      const promptStart = frame.length;
+      frame.push(...prompt.lines);
+      frame.push('');
+      frame.push(footer);
+      this._promptTop = promptStart;
+      if (prompt.cursor) cursor = { row: promptStart + prompt.cursor.row, col: prompt.cursor.col };
+    }
+
+    while (frame.length < H) frame.push('');
+    frame = frame.slice(0, H).map((line) => R.vpad(R.vclip(line, W), W));
+    if (cursor && (cursor.row < 0 || cursor.row >= H)) cursor = null;
+
+    if (st.input.startsWith('/') && !st.overlay && !st.approval && !st.prompt) {
+      const list = this.slashList();
+      if (list.length) frame = this.overlaySlash(frame, W, H, list);
+    }
+    if (st.overlay) frame = this.renderOverlay(frame, W, H);
+    if (st.approval) frame = this.renderApproval(frame, W, H);
+    if (st.prompt) frame = this.renderPrompt(frame, W, H);
+    if (st.toast) frame = this.renderToast(frame, W, H);
+
+    frame = frame.map((line) => R.vpad(R.vclip(line, W), W));
+    this.term.draw(frame);
+
+    if (!cursor || st.overlay || st.approval || st.prompt) this.term.hideCursor();
+    else this.term.placeCursor(cursor.row, Math.min(W - 1, Math.max(0, cursor.col)));
+
+    this.rendering = false;
+    if (this.dirty) setTimeout(() => this.maybeRender(), 16);
+  }
+
+  notifyLine(W) {
+    const t = this.theme;
+    const st = this.state;
+    if (!st.connected) {
+      return W2.notifyLine(t, { width: W, command: '/connect', text: ` bridge offline at ${this.url}` });
+    }
+    return '';
+  }
+
+  tipLine(W) {
+    const t = this.theme;
+    const tips = [
+      ['ctrl+p', ' for every command'],
+      ['/tasks', ' to see the queue'],
+      ['tab', ' to switch between agents'],
+      ['@file', ' to attach a file to the message'],
+      ['!cmd', ' to run something locally'],
+    ];
+    const tip = tips[Math.floor((Date.now() - this.state.startedAt) / 7000) % tips.length];
+    const width = W;
+    const body = `${t.warning('● Tip ')}${t.muted(tip[0].startsWith('/') || tip[0].startsWith('@') || tip[0].startsWith('!') ? 'Run ' : 'Press ')}${t.fg(tip[0])}${t.muted(tip[1])}`;
+    const left = Math.max(0, Math.floor((width - R.vlen(body)) / 2));
+    return R.spaces(left) + body;
+  }
+
+  slashList() {
+    const q = this.state.input.slice(1).toLowerCase().split(' ')[0];
+    const all = [...this.slashCommands(), ...this.commands()];
+    return all.filter((c) => !q || c.slash.replace('/', '').startsWith(q)).slice(0, 7);
+  }
+
+  overlaySlash(frame, W, H, list) {
+    const t = this.theme;
+    const { bgSeq } = require('./theme');
+    const width = this.promptWidth(W);
+    const pad = this.isHome() ? Math.max(0, Math.floor((W - width) / 2)) : 2;
+    const lines = list.map((cmd, i) => {
+      const active = i === (this.state.slashIndex || 0);
+      const bg = active ? bgSeq(t.c.backgroundElement) : bgSeq(t.c.backgroundPanel);
+      const label = `${active ? '\x1b[1m' : ''}${fgSeqOf(t, active ? t.c.text : t.c.textMuted)}${cmd.slash}${RESET_OF()}${t.muted('  ' + cmd.title)}`;
+      const hint = t.muted(cmd.hint || '');
+      const body = R.spaces(1) + label + R.spaces(Math.max(1, width - 3 - R.vlen(label) - R.vlen(hint))) + hint + R.spaces(1);
+      return R.spaces(pad) + W2.bgWrap(bg, body, width);
+    });
+    const y = Math.max(0, (this._promptTop || H - 8) - lines.length - 1);
+    return R.overlay(frame, lines, 0, y);
+  }
+
+  renderOverlay(frame, W, H) {
+    const ov = this.state.overlay;
+    const t = this.theme;
+    let dialog;
+
+    if (ov.type === 'palette') {
+      const list = this.filteredCommands();
+      const items = [];
+      let lastGroup = null;
+      for (const cmd of list.slice(0, Math.max(4, H - 12))) {
+        const group = cmd.group || 'Commands';
+        if (group !== lastGroup) {
+          items.push({ group });
+          lastGroup = group;
+        }
+        items.push({ label: cmd.title, hint: cmd.hint || '', grouped: true });
+      }
+      dialog = D.listDialog(t, {
+        W,
+        title: 'Commands',
+        filter: ov.query || '',
+        items,
+        index: ov.index,
+        footer: [
+          ['enter', 'run'],
+          ['esc', 'close'],
+        ],
+      });
+    } else if (ov.type === 'help') {
+      const rows = HELP_ROWS();
+      const items = [];
+      let lastGroup = null;
+      for (const [group, key, label] of rows) {
+        if (group !== lastGroup) {
+          items.push({ group });
+          lastGroup = group;
+        }
+        items.push({ label, hint: key, group: '' });
+      }
+      dialog = D.listDialog(t, { W, size: 'large', title: 'Help', filter: '', items, index: -1, footer: [['esc', 'close']] });
+    } else {
+      const items = [{ group: 'Queue' }];
+      if (ov.loading) items.push({ label: 'loading…', dim: true });
+      else if (!ov.tasks.length) items.push({ label: 'no tasks', dim: true });
+      else for (const task of ov.tasks.slice(0, Math.max(4, H - 12))) items.push({ label: `${task.state}  ${R.vclip(task.id, 22)}  ${R.vclip(String(task.instruction).split('\n').slice(-1)[0], 40)}`, grouped: true });
+      dialog = D.listDialog(t, { W, size: 'large', title: 'Sessions', filter: '', items, index: -1, footer: [['esc', 'close']] });
+    }
+
+    const y = D.dialogY(H, dialog.lines.length);
+    return R.overlayDim(frame, dialog.lines, dialog.x, y);
+  }
+
+  renderApproval(frame, W, H) {
+    const ap = this.state.approval;
+    const t = this.theme;
+    const labels = { y: 'Run once', a: 'Approve', n: "Don't run", r: 'Reject', f: 'Revise' };
+    const options = ap.options.map((o) => ({ label: labels[o.key] || o.label, key: o.key, hint: o.key }));
+    const dialog = D.confirmDialog(t, {
+      W,
+      title: titleCase(ap.title || 'Permission'),
+      subject: ap.subject || '',
+      note: ap.note || '',
+      options,
+      index: Math.max(0, ap.index || 0),
+      footer: [
+        ['↑↓', 'select'],
+        ['enter', 'confirm'],
+        ['esc', 'cancel'],
+      ],
+    });
+    const y = D.dialogY(H, dialog.lines.length);
+    return R.overlayDim(frame, dialog.lines, dialog.x, y);
+  }
+
+  renderPrompt(frame, W, H) {
+    const t = this.theme;
+    const p = this.state.prompt;
+    const width = Math.min(60, W - 8);
+    const inside = `${t.muted(p.question)} ${t.fg(p.value)}${t.inverse(' ')}`;
+    const lines = [
+      W2.bgWrap(require('./theme').bgSeq(t.c.backgroundPanel), '  ' + inside, width - 4),
+    ];
+    const block = [
+      W2.bgWrap(require('./theme').bgSeq(t.c.backgroundPanel), '  ' + t.bold('Revise') + R.spaces(Math.max(1, width - 12 - R.vlen(p.question))) + t.muted('enter'), width),
+      W2.bgWrap(require('./theme').bgSeq(t.c.backgroundPanel), '', width),
+      ...lines,
+      W2.bgWrap(require('./theme').bgSeq(t.c.backgroundPanel), '', width),
+    ];
+    const x = Math.max(0, Math.floor((W - width) / 2));
+    const y = D.dialogY(H, block.length);
+    return R.overlay(frame, block, x, y);
+  }
+
+  renderToast(frame, W, H) {
+    const t = this.theme;
+    const toast = this.state.toast;
+    const tone = toast.tone === 'error' ? t.err : toast.tone === 'warn' ? t.warn : t.primary;
+    const text = ` ${tone(toast.text)} `;
+    const x = Math.max(0, Math.floor((W - R.vlen(text)) / 2));
+    return R.overlay(frame, [text], x, H - 4);
+  }
+
+  quit() {
+    this.running = false;
+    this.term.exit();
+    process.exit(0);
+  }
+}
+
+function HELP_ROWS() {
+  return [
+    ['Prompt', 'enter', 'send the message'],
+    ['Prompt', 'shift+enter', 'newline'],
+    ['Prompt', 'esc', 'interrupt the turn'],
+    ['Prompt', 'tab', 'switch agent / plan'],
+    ['Prompt', 'ctrl+p', 'command palette'],
+    ['Prompt', '/', 'slash commands'],
+    ['Prompt', '@', 'attach a file from the folder'],
+    ['Prompt', '!', 'run a command locally'],
+    ['Prompt', 'up / down', 'history'],
+    ['Session', 'ctrl+x n', 'new session'],
+    ['Session', 'ctrl+x l', 'task queue'],
+    ['Session', 'ctrl+x t', 'switch theme'],
+    ['Session', 'ctrl+x d', 'toggle tool output'],
+    ['Session', 'ctrl+x b', 'toggle the sidebar'],
+    ['Session', 'pgup / pgdn', 'scroll'],
+    ['Session', 'ctrl+l', 'clear the timeline'],
+    ['Session', 'ctrl+c', 'interrupt, then quit'],
+    ['Session', 'ctrl+x q', 'quit'],
+  ];
+}
+
+function fgSeqOf(t, color) {
+  return require('./theme').fgSeq(color);
+}
+
+function RESET_OF() {
+  return require('./theme').RESET;
+}
+
+function titleCase(text) {
+  return String(text)
+    .split(' ')
+    .map((word) => (word ? word[0].toUpperCase() + word.slice(1) : word))
+    .join(' ');
+}
+
+module.exports = { App, MODE_LINES, HELP_ROWS, titleCase };