@elu-labs/elu 0.0.0-stage → 0.1.0

package/lib/shell.mjs

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { killGroup } from './process.mjs';
+import { taskDir } from './state.mjs';
+import { dataBlock, noSymlinks } from './util.mjs';
+import { redact } from './publish.mjs';
+
+// Commands the owner runs from the message box with ! (README, "Commands").
+// A command typed in an open session is saved beside it, one JSON line per command:
+//   {at, command, cwd, output, code, signal, stopped, error}
+// The chat shows these rows, and the lead gets them with the owner's next message.
+// Possible secrets in the output are masked before a row is saved.
+export const OUTPUT_MAX = 8000, TIME_LIMIT_MS = 10 * 60000;
+const HEAD = 100000, TAIL = 300000, ROWS = 20, FILE_MAX = 1024 * 1024;
+
+// Output as plain text: no colour codes or cursor moves, and a line redrawn with a
+// carriage return keeps its last state.
+export function plainOutput(value) {
+  return String(value ?? '').replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '').replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/\x1b[@-Z\\-_]/g, '')
+    .replace(/\r\n/g, '\n').split('\n').map(line => line.slice(line.lastIndexOf('\r') + 1)).join('\n').replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '');
+}
+// A long output loses its middle, so the start and the end both stay.
+export function fitOutput(text, max = OUTPUT_MAX) {
+  if (text.length <= max) return text;
+  const head = Math.floor(max * 0.4);
+  return `${text.slice(0, head)}\n[… ${text.length - max} characters cut …]\n${text.slice(head - max)}`;
+}
+// Runs one command in the user's shell, with no input and no terminal of its own.
+// done resolves (never rejects) with {output, code, signal, stopped, error}; tail() is the
+// end of the output so far; stop() ends the command and everything it started.
+export function runShell(command, { cwd, env = process.env, onOutput = () => {}, limitMs = TIME_LIMIT_MS } = {}) {
+  let head = '', tail = '', dropped = 0, stopped = null, child = null, timer = null, settle = null;
+  const all = () => plainOutput(dropped ? `${head}\n[… ${dropped} characters cut …]\n${tail}` : head + tail);
+  const take = text => {
+    const room = HEAD - head.length;
+    head += text.slice(0, Math.max(0, room)); tail += text.slice(Math.max(0, room));
+    if (tail.length > TAIL) { dropped += tail.length - TAIL; tail = tail.slice(-TAIL); }
+    onOutput();
+  };
+  const stop = (reason = 'stopped') => {
+    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+    stopped ??= reason;
+    const kill = signal => { if (process.platform === 'win32') child.kill(signal); else killGroup(child.pid, signal); };
+    kill('SIGTERM'); setTimeout(() => kill('SIGKILL'), 2000).unref();
+  };
+  const done = new Promise(resolve => {
+    let finished = false;
+    const finish = (code, signal, error = null) => {
+      if (finished) return; finished = true; clearTimeout(timer); clearTimeout(settle);
+      resolve({ output: redact(fitOutput(all().trimEnd()), OUTPUT_MAX + 200), code, signal, stopped, error });
+    };
+    try { child = spawn(command, { cwd, env, shell: process.env.SHELL || true, stdio: ['ignore', 'pipe', 'pipe'], detached: process.platform !== 'win32', windowsHide: true }); }
+    catch (error) { finish(null, null, error.message); return; }
+    for (const stream of [child.stdout, child.stderr]) { stream.setEncoding('utf8'); stream.on('data', take); stream.on('error', () => {}); }
+    child.on('error', error => finish(null, null, error.message));
+    child.on('close', (code, signal) => finish(code, signal));
+    // A command that leaves something running in the background ends when its shell does.
+    child.on('exit', (code, signal) => { settle = setTimeout(() => { child.stdout.destroy(); child.stderr.destroy(); finish(code, signal); }, 500); });
+    timer = setTimeout(() => stop('time'), limitMs);
+  });
+  return { done, stop, tail: (max = 4000) => plainOutput((head + tail).slice(-max)) };
+}
+
+const file = (repo, id) => path.join(taskDir(repo, id), 'shell.jsonl');
+export const shellFile = file;
+export function recordShell(repo, id, row) {
+  const target = file(repo, id); noSymlinks(target);
+  fs.appendFileSync(target, `${JSON.stringify(row)}\n`, { mode: 0o600 });
+}
+// The newest rows of a session, oldest first. A torn or foreign line is skipped.
+export function shellRows(repo, id, limit = ROWS) {
+  let text;
+  try {
+    const target = file(repo, id); noSymlinks(target);
+    const size = fs.statSync(target).size, fd = fs.openSync(target, 'r');
+    try { const buffer = Buffer.alloc(Math.min(size, FILE_MAX)); fs.readSync(fd, buffer, 0, buffer.length, size - buffer.length); text = buffer.toString('utf8'); }
+    finally { fs.closeSync(fd); }
+  } catch { return []; }
+  const rows = [];
+  for (const line of text.split('\n')) {
+    try { const row = JSON.parse(line); if (row && typeof row.command === 'string' && typeof row.at === 'string') rows.push(row); } catch { /* Skipped. */ }
+  }
+  return rows.slice(-limit);
+}
+// How a finished command reads, in the chat and to the lead: the command, its output, and how it ended.
+const shellEnd = row => row.error ? `could not start: ${row.error}` : row.stopped === 'time' ? 'stopped: it ran for 10 minutes' : row.stopped ? 'stopped' : row.signal ? `ended by ${row.signal}` : row.code ? `exit ${row.code}` : '';
+export function shellText(row) {
+  return [`$ ${row.command}`, typeof row.output === 'string' ? row.output : '', shellEnd(row)].filter(Boolean).join('\n');
+}
+// A finished command as a model reads it. The command line is the owner's, and how it ended
+// is the app's. What it printed is whatever the files and programs it touched put there, so
+// it travels in a data block of its own and is never read as the owner's words.
+export function shellForModel(row) {
+  const output = typeof row.output === 'string' ? row.output : '';
+  return { text: [`$ ${row.command}`, shellEnd(row)].filter(Boolean).join('\n'), ...(output ? { output: dataBlock('Output of this command', output) } : {}) };
+}
+// The lead's copy of a session's commands, as messages in time order with the owner's own.
+export function shellMessages(repo, id) {
+  return shellRows(repo, id).map(row => { const { text, output } = shellForModel(row); return { at: row.at, shell: true, text: `The owner ran this in ${row.cwd ?? 'the project'}:\n${text}`, ...(output ? { output } : {}) }; });
+}

package/lib/state.mjs

@@ -0,0 +1,247 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { atomic, mkdir, readJson, noSymlinks, refuse } from './util.mjs';
+import { processIdentity } from './process.mjs';
+import { checkPlace } from './modes.mjs';
+
+export function event(repo, type, data = {}) {
+  mkdir(repo.state);
+  const file = path.join(repo.state, 'events.jsonl'); noSymlinks(file);
+  fs.appendFileSync(file, `${JSON.stringify({ id: crypto.randomUUID(), at: new Date().toISOString(), type, ...data })}\n`, { mode: 0o600 });
+}
+export function tasks(repo) {
+  const folder = path.join(repo.state, 'tasks'); noSymlinks(folder);
+  if (!fs.existsSync(folder)) return [];
+  return fs.readdirSync(folder).filter((id) => /^[1-9][0-9]*$/.test(id)).map((id) => readTask(repo, id)).sort((a, b) => Number(a.id) - Number(b.id));
+}
+export function taskDir(repo, id) {
+  if (!/^[1-9][0-9]*$/.test(String(id))) refuse('Task ID must be a positive integer.');
+  const dir = path.join(repo.state, 'tasks', String(id)); noSymlinks(dir); return dir;
+}
+// A session's records stay with its project. Its edit can run in another repository the
+// lead found; there, its folder and branch carry a project mark, so two projects editing
+// one repository never collide. A repo object for such an edit has `project` set.
+const worktreesOf = root => path.join(path.dirname(root), `${path.basename(root)}.elu-code`);
+export const projectMark = root => crypto.createHash('sha256').update(root).digest('hex').slice(0, 6);
+// place: a new worktree (default), a worktree with a named branch checked
+// out, or `here`, the real checkout itself, whose branch is whatever is checked out.
+export function taskPlace(repo, id, repository = null, place = null) {
+  const project = repo.project ?? repo.root, kind = place?.kind ?? 'worktree';
+  if (kind === 'here') return { worktree: repository ?? repo.root, branch: null };
+  const own = !repository || repository === project, name = own ? String(id) : `${id}-${projectMark(project)}`;
+  const worktree = path.join(own ? project === repo.root ? repo.worktrees : worktreesOf(project) : worktreesOf(repository), name);
+  return { worktree, branch: kind === 'branch' ? place.branch : `feat/task-${name}` };
+}
+const BRANCH = /^[A-Za-z0-9._/-]{1,200}$/;
+// What the owner sets for a session: its mode, spending limit, folders and bots. A turn
+// holds the session for its whole length and writes its own copy of the record back at
+// each step, so a setting changed meanwhile is kept in a small file beside the record.
+// Every read lays that file over the record, and the next save takes it into the record
+// and into the saver's own copy: the turn's, at the latest when it ends. null takes a
+// value away.
+const SETTINGS = ['permissions', 'permissionChanges', 'budgetUsd', 'folders', 'bots'];
+const recordFile = (repo, id) => path.join(taskDir(repo, id), 'task.json');
+export const settingsFile = (repo, id) => path.join(taskDir(repo, id), 'settings.json');
+function waitingSettings(repo, id) {
+  const file = settingsFile(repo, id); noSymlinks(file);
+  if (!fs.existsSync(file)) return null;
+  try { const value = readJson(file); return value && typeof value === 'object' && !Array.isArray(value) ? value : null; } catch { return null; }
+}
+function laySettings(task, waiting) {
+  for (const key of SETTINGS) if (waiting && Object.hasOwn(waiting, key)) { if (waiting[key] === null) delete task[key]; else task[key] = waiting[key]; }
+  return task;
+}
+// Changes a session's settings whether or not a turn holds it; no caller waits for a turn.
+// change gets the session as it reads now and alters its settings. Returns the session as
+// it reads after.
+export function changeSettings(repo, taskId, change) {
+  const release = waitLock(repo, `settings-${taskId}`);
+  try {
+    const task = readTask(repo, taskId), was = SETTINGS.map(key => JSON.stringify(task[key]));
+    change(task);
+    const changed = SETTINGS.filter((key, index) => JSON.stringify(task[key]) !== was[index]);
+    if (!changed.length) return task;
+    let turn = null;
+    try { turn = lock(repo, `task-${taskId}`); } catch (error) { if (!error.message.includes('holds this lock')) throw error; }
+    const file = settingsFile(repo, taskId); noSymlinks(file);
+    if (!turn) { atomic(file, { ...waitingSettings(repo, taskId), ...Object.fromEntries(changed.map(key => [key, task[key] ?? null])) }); return task; }
+    try { atomic(recordFile(repo, taskId), task); fs.rmSync(file, { force: true }); } finally { turn(); }
+    return task;
+  } finally { release(); }
+}
+// A record is read with what is kept beside it laid over it: the name, then the settings.
+export function readTask(repo, id) { return laySettings(named(repo, record(repo, id)), waitingSettings(repo, id)); }
+function record(repo, id) {
+  const task = readJson(path.join(taskDir(repo, id), 'task.json'));
+  if (task.kind === 'conversation') {
+    if (task.id !== String(id) || task.worktree !== (repo.project ?? repo.root) || task.base !== null || task.branch !== null) refuse('Invalid conversation record.');
+    return task;
+  }
+  if (task.repository !== undefined && (typeof task.repository !== 'string' || !path.isAbsolute(task.repository))) refuse('Invalid task record.');
+  let place = null;
+  if (task.place !== undefined) { try { place = checkPlace(task.place, { mode: 'full' }); } catch { refuse('Invalid task record.'); } }
+  const expected = taskPlace(repo, id, task.repository, place);
+  const branchOk = place?.kind === 'here' ? task.branch === null || typeof task.branch === 'string' && BRANCH.test(task.branch) : task.branch === expected.branch;
+  if (task.id !== String(id) || task.worktree !== expected.worktree || !branchOk || !/^[0-9a-f]{40,64}$/.test(task.base ?? '')) refuse('Invalid task record.');
+  return task;
+}
+export function saveTask(repo, task) {
+  const waiting = settingsFile(repo, task.id); noSymlinks(waiting);
+  if (!fs.existsSync(waiting)) { atomic(recordFile(repo, task.id), task); return; }
+  const release = waitLock(repo, `settings-${task.id}`);
+  try { laySettings(task, waitingSettings(repo, task.id)); atomic(recordFile(repo, task.id), task); fs.rmSync(waiting, { force: true }); } finally { release(); }
+}
+// A session's name in lists and titles: the one the owner gave it, else the title of its
+// approved Task, else the short one the model chose in its first reply, else the first
+// words of what was asked. The name is kept beside the record, in a file of its own, with
+// who chose it. A running turn holds the record and its lock until it ends, and saves the
+// record as it goes: a name in its own file is saved at once, and those saves never undo it.
+export const TITLE_MAX = 60;
+export const MODEL_TITLE_MAX = 40;
+export const nameFile = (repo, id) => path.join(taskDir(repo, id), 'name.json');
+// What the name file holds, or null when there is none. A file that cannot be read counts as none.
+function savedName(repo, id) {
+  try { const value = readJson(nameFile(repo, id)); return value && typeof value === 'object' && !Array.isArray(value) ? value : null; } catch { return null; }
+}
+// A name that was saved: the owner's, read back. Older versions took up to 120 characters.
+const kept = value => { const name = typeof value === 'string' ? oneLine(value) : ''; return name && name.length <= 120 && !/[\x00-\x1f\x7f]/.test(name) ? name : null; };
+// Puts the saved name on a record that was just read: title, and titleBy for who chose it,
+// owner, task or model. Without a name file the record keeps the name older versions saved
+// in it, which the owner chose.
+function named(repo, task) {
+  const name = savedName(repo, task.id);
+  if (!name) return task;
+  const owner = kept(name.owner), plan = owner ? null : planTitle(name.task), model = owner ?? plan ? null : modelTitle(name.model), title = owner ?? plan ?? model;
+  delete task.title; delete task.titleBy;
+  if (title) { task.title = title; task.titleBy = owner ? 'owner' : plan ? 'task' : 'model'; }
+  return task;
+}
+// What the name file holds, to change one part of it. A name older versions saved in the
+// record is carried over as the owner's; a copy a turn saved there of a name that someone
+// else chose is not.
+function nameParts(repo, id) {
+  const saved = record(repo, id), before = saved.titleBy && saved.titleBy !== 'owner' ? null : kept(saved.title);
+  return savedName(repo, id) ?? (before ? { owner: before } : {});
+}
+const UNSEEN = /[\x00-\x1f\x7f-\x9f\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/;
+const oneLine = value => String(value ?? '').replace(/\s+/g, ' ').trim();
+// The first words of a request, in one row: cut at a word boundary, with … for the rest.
+function firstWords(value, width) {
+  const text = oneLine(value);
+  if (text.length <= width) return text;
+  // A cut that falls right after a word keeps that word.
+  const cut = text.slice(0, width - 1), space = cut.lastIndexOf(' '), whole = /[\s,;:.!?]/.test(text[width - 1]);
+  return `${(whole || space <= 0 ? cut : cut.slice(0, space)).replace(/[\s,;:.!?-]+$/, '')}…`;
+}
+// A name the model gave is untrusted text. It is taken only as 2 to 6 plain words on one
+// line, of up to MODEL_TITLE_MAX characters: no control or invisible characters, no markup,
+// no address, no file path. A word with a slash is two plain words joined by it, as in
+// read/write. Anything else is not a name: null, and the session keeps the one it shows.
+export function modelTitle(value) {
+  if (typeof value !== 'string' || UNSEEN.test(value.trim())) return null;
+  const name = value.trim().replace(/^["'“”‘’]+|["'“”‘’.]+$/g, '').replace(/ +/g, ' ').trim(), words = name ? name.split(' ') : [];
+  if (name.length > MODEL_TITLE_MAX || words.length > 6 || !/[\p{L}\p{N}]/u.test(name)) return null;
+  // One word is a name only in a script that writes without spaces.
+  if (words.length < 2 && /^[\x20-\u024f]*$/.test(name)) return null;
+  if (/[<>{}[\]`*|\\~]|^#|:\/\//.test(name)) return null;
+  if (words.some(word => word.includes('/') && !/^\p{L}+\/\p{L}+$/u.test(word))) return null;
+  return name;
+}
+// true when the session has a name that someone chose: the owner, an approved Task or the model.
+export function hasTitle(repo, taskId) { return Boolean(readTask(repo, taskId).title); }
+// Saves the name the model chose, once. It never replaces the owner's name, which stays
+// the one that shows, nor an earlier name of its own. false when it is not a name or the
+// session has one from the model already.
+export function suggestTitle(repo, taskId, value) {
+  const name = modelTitle(value);
+  if (!name) return false;
+  const release = waitLock(repo, `name-${taskId}`);
+  try {
+    const saved = nameParts(repo, taskId);
+    if (modelTitle(saved.model)) return false;
+    atomic(nameFile(repo, taskId), { ...saved, model: name }); return true;
+  } finally { release(); }
+}
+// A Task's title as a session name: one line, cut at a word to TITLE_MAX. null when it is
+// empty or holds a control or invisible character.
+function planTitle(value) { const name = typeof value === 'string' ? firstWords(value, TITLE_MAX) : ''; return name && !UNSEEN.test(name) ? name : null; }
+// Names a session after its approved Task, whatever the session is doing. It replaces the
+// title of an earlier Task and shows in place of the model's short name, and never in place
+// of a name the owner set: that one stays until the owner takes it away. An empty title
+// takes the Task's away again. false, and nothing changes, when the title is not plain text.
+export function titleFromTask(repo, taskId, title) {
+  const name = planTitle(title);
+  if (!name && String(title ?? '').trim()) return false;
+  const release = waitLock(repo, `name-${taskId}`);
+  try {
+    const saved = nameParts(repo, taskId); delete saved.task;
+    atomic(nameFile(repo, taskId), name ? { ...saved, task: name } : saved); return true;
+  } finally { release(); }
+}
+// Why a typed name is not taken, or null.
+export function nameProblem(value) {
+  const name = oneLine(value), rule = `A session name is one line of up to ${TITLE_MAX} characters.`;
+  return /[\x00-\x1f\x7f]/.test(name) ? rule : name.length > TITLE_MAX ? `${rule} This one is ${name.length}.` : null;
+}
+export function taskTitle(task) {
+  const name = typeof task?.title === 'string' ? task.title.trim() : '';
+  return name || firstWords(String(task?.goal ?? '').split('\n').find(line => line.trim()) ?? '', TITLE_MAX);
+}
+// Renames a session, whatever it is doing. An empty name takes the owner's name away again.
+export function setTitle(repo, taskId, title) {
+  const name = oneLine(title), problem = nameProblem(name);
+  if (problem) refuse(problem);
+  record(repo, taskId);
+  const release = waitLock(repo, `name-${taskId}`);
+  try { atomic(nameFile(repo, taskId), { ...savedName(repo, taskId), owner: name || null }); } finally { release(); }
+  return readTask(repo, taskId);
+}
+// A lock is written whole under another name and then linked to its own, so a process that
+// finds it never reads half of one, and the first to link wins.
+const NO_LINKS = ['EPERM', 'ENOTSUP', 'EOPNOTSUPP', 'ENOSYS'], HALF_AGE_MS = 5000, GONE = Symbol('gone'), HALF = Symbol('half');
+function claim(file, text) {
+  const draft = `${file}.${process.pid}.tmp`;
+  fs.rmSync(draft, { force: true });
+  fs.writeFileSync(draft, text, { flag: 'wx', mode: 0o600 });
+  try { fs.linkSync(draft, file); }
+  catch (error) {
+    if (!NO_LINKS.includes(error.code)) throw error;
+    // A file system without hard links: written in place, as before.
+    fs.writeFileSync(file, text, { flag: 'wx', mode: 0o600 });
+  } finally { fs.rmSync(draft, { force: true }); }
+}
+// Who holds the lock that was found. It may be released between the two looks, and where
+// there are no hard links it may be half written: by its holder now, or by one that died,
+// whose half is removed once it is old.
+function holder(file) {
+  try { return readJson(file); }
+  catch (error) {
+    if (error.code === 'ENOENT') return GONE;
+    if (!(error instanceof SyntaxError)) throw error;
+    try { if (Date.now() - fs.statSync(file).mtimeMs < HALF_AGE_MS) return HALF; } catch { return GONE; }
+    fs.rmSync(file, { force: true }); return GONE;
+  }
+}
+export function lock(repo, name = 'allocate') {
+  mkdir(repo.state);
+  const file = path.join(repo.state, `${name}.lock`); noSymlinks(file);
+  const text = JSON.stringify({ pid: process.pid, identity: processIdentity(process.pid) });
+  let stale = 0;
+  // A lock that was released, or removed as half written, between the two looks is tried for again.
+  for (let look = 0; stale < 2 && look < 50; look++) {
+    try { claim(file, text); return () => { noSymlinks(file); fs.unlinkSync(file); }; }
+    catch (error) { if (error.code !== 'EEXIST') throw error; }
+    const previous = holder(file);
+    if (previous === GONE) continue;
+    if (previous === HALF || !previous?.identity || processIdentity(previous.pid) === previous.identity) refuse('Another ELU Code command holds this lock.');
+    fs.rmSync(file, { force: true }); stale++;
+  }
+  refuse(stale ? 'Could not take the repository lock.' : 'Another ELU Code command holds this lock.');
+}
+export function waitLock(repo, name, attempts = 60) {
+  for (let attempt = 0; ; attempt++) {
+    try { return lock(repo, name); }
+    catch (error) { if (attempt >= attempts || !error.message.includes('holds this lock')) throw error; Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10); }
+  }
+}

package/lib/terminal-bots.mjs

@@ -0,0 +1,239 @@
+// The Bots tab: its list rows and its dialogs, and the @name that sends a message to a bot.
+// The terminal hands in its own dialogs, so nothing here touches the screen.
+import { BOT_COLORS, botColor, botVendors, botEfforts, botNameProblem, botModelProblem, botServers, botServersProblem, botRoomProblem, botWorks, getBot, listBots, pickBotColor, saveBot, removeBot, botRuns, botShadows, SCHEDULE_MAX } from './bots.mjs';
+import { botModels, matchModels, ownEffort } from './bot-models.mjs';
+import { botScheduleProblem, botScheduleSpec } from './bot-schedules.mjs';
+import { claudeServers } from './mcp.mjs';
+import { VENDOR_NAMES } from './vendors.mjs';
+import { ink, fitWords, wrapText } from './terminal-visuals.mjs';
+
+export const NO_BOTS = 'No bots yet. A bot is a model with instructions you write once and use in any chat. Press n to make one.';
+// Text in whole words; nothing when there is no room for a couple of them.
+const words = (text, room) => room >= Math.min(text.length, Math.max(16, text.split(' ', 1)[0].length + 1)) ? fitWords(text, room) : '';
+
+// When a bot runs by itself, as /schedule reads it: "weekdays 9:00". The saved text when it
+// can no longer be read, and null when the bot has no schedule.
+const scheduleText = bot => botScheduleSpec(bot)?.label ?? bot.schedule ?? null;
+// "elu and github": names in a sentence.
+const listed = names => names.length > 1 ? `${names.slice(0, -1).join(', ')} and ${names.at(-1)}` : names[0] ?? '';
+// What is said of MCP servers a bot names that Claude Code does not have, or null for none.
+const notSetUp = names => names.length ? `${listed(names)} ${names.length > 1 ? 'are' : 'is'} not set up in Claude Code yet.` : null;
+const onlyClaude = vendor => `MCP servers reach Claude runs only. This bot runs on ${vendor}.`;
+
+// Who picks a model or an effort the bot does not name: its vendor's own command line.
+const own = vendor => `${VENDOR_NAMES[vendor] ?? vendor}'s own`;
+// A bot's model and effort as its page names them, never the word default. named(bot) is
+// the name a session shows that model by; for a bot that names no model it is the model
+// the bot's latest run reported, or null before one did. An effort the bot does not name
+// is the one the vendor's model list gives that model. Where a value was never read, the
+// row says who picks it.
+export const botModelText = (bot, named = () => null) => named(bot) ?? bot.model ?? own(bot.vendor);
+export function botEffortText(bot) {
+  if (bot.effort) return bot.effort;
+  return botEfforts(bot.vendor).length ? ownEffort(bot.vendor, bot.model) ?? own(bot.vendor) : 'no setting';
+}
+// The model a bot's helpers run on, by the name a session shows that model by, or none.
+export const botSubagentsText = (bot, named = () => null) => bot.subagents ? named({ vendor: 'claude', model: bot.subagents }) ?? bot.subagents : 'none';
+// One row per bot: @name in its colour, what it runs on (vendor, model by name, effort when it names
+// one), its helpers' model, its schedule or that it works when written to, its MCP servers
+// (two names, then +N), whether it shadows, whether teammates can use it, then what it is for.
+export function botLines(bots, width, colour, named = () => null) {
+  if (!bots.length) return wrapText(NO_BOTS, width - 1).map(line => ink(` ${line}`, 'muted', colour));
+  const column = Math.max(...bots.map(bot => bot.name.length)) + 3;
+  return bots.map(bot => {
+    const mcp = bot.mcp ?? [], servers = mcp.length ? `mcp ${mcp.slice(0, 2).join(' ')}${mcp.length > 2 ? ` +${mcp.length - 2}` : ''}` : null;
+    const on = [bot.vendor, named(bot) ?? bot.model, bot.effort ? `${bot.effort} effort` : null].filter(Boolean).join(' · ');
+    const helpers = bot.subagents ? `${botSubagentsText(bot, named)} helpers` : null, works = scheduleText(bot) ?? (bot.works ? 'works when written to' : null);
+    const runs = fitWords([on, helpers, works, servers, botShadows(bot) ? 'shadows' : null, bot.shared ? 'teammates can use it' : null].filter(Boolean).join(' · '), width - column), about = words(bot.about, width - column - runs.length - 2);
+    return ink(`@${bot.name}`.padEnd(column), botColor(bot), colour, true) + ink(runs, 'text', colour) + (about ? ink(`  ${about}`, 'muted', colour) : '');
+  });
+}
+// "@sec @docs +2": the bots in a chat, as many whole names as fit, for the message box's label.
+export function botNames(names, room = 28) {
+  const shown = [];
+  for (const name of names) {
+    const rest = names.length - shown.length - 1, text = [...shown, `@${name}`].join(' ') + (rest ? ` +${rest}` : '');
+    if (shown.length && text.length > room) break;
+    shown.push(`@${name}`);
+  }
+  return shown.join(' ') + (shown.length < names.length ? ` +${names.length - shown.length}` : '');
+}
+// A message that starts with @name, where name is a saved bot: the bot and the text for it.
+// null when the first word is not a bot, so the message goes where it went before.
+export function botMessage(text, bots) {
+  const match = /^@([A-Za-z][A-Za-z0-9-]{0,29})(?:\s+([\s\S]*))?$/.exec(String(text ?? '').trim());
+  const bot = match && bots.find(row => row.name === match[1].toLowerCase());
+  return bot ? { bot, text: (match[2] ?? '').trim() } : null;
+}
+
+// What the page of a bot says under its rows: where its schedule runs, the MCP servers that
+// will not reach it, and what it was saved to do that no row shows: its helpers, that it
+// may merge pull requests, that it speaks after each turn. servers are the names Claude
+// Code has.
+export function botNotes(bot, servers) {
+  const missing = bot.mcp.filter(name => !servers.includes(name));
+  return [
+    bot.subagents ? botWorks(bot) ? "Its helpers work under the session's permissions, as the bot does." : 'Its helpers start only when the bot works. Give it a schedule to make it work.' : null,
+    botScheduleSpec(bot) ? `Runs by itself in each session it is in. /bots schedule off ${bot.name} stops it in one session.` : botScheduleProblem(bot.schedule),
+    bot.mcp.length && bot.vendor !== 'claude' ? onlyClaude(bot.vendor) : null,
+    missing.length ? `${notSetUp(missing)}${missing.includes('elu') ? ` npx @elu-labs/mcp-setup connects ${missing.length > 1 ? 'elu' : 'it'}.` : ''}` : null,
+    bot.merge ? 'It may merge pull requests. Ask for approval mode still asks you before each merge.' : null,
+    bot.shadow ? botShadows(bot) ? SHADOW_NOTE : 'This bot works in its sessions, so it does not speak after each turn.' : null,
+  ].filter(Boolean);
+}
+
+const SCHEDULE_HINT = 'When this bot runs by itself. Empty means it never does.';
+// What a bot saved to speak after each turn does, as its page says it.
+const SHADOW_NOTE = 'After a turn that changes no files it reads that turn and says what it would challenge. It reads only, and it still reviews each change.';
+const SCHEDULES = [{ name: 'every 1h', note: 'each hour' }, { name: 'daily 9:00', note: 'every day at 9:00' }, { name: 'weekdays 9am', note: 'Monday to Friday at 9:00' }];
+const serversHint = vendor => `The MCP servers this bot may use, by the names claude mcp list shows. Separate several with commas or spaces. Empty means none.${vendor === 'claude' ? '' : `\n${onlyClaude(vendor)}`}`;
+
+// The dialogs, built on the terminal's own: prompt (one line), listDialog (rows), editSetting
+// (the instructions editor), yes (a confirm) and setMessage (the status line). root gives
+// the open project's folder, whose Claude Code MCP servers are offered with the owner's own.
+// named: the name a bot's model is shown by (see botModelText).
+export function botDialogs({ prompt, listDialog, editSetting, yes, setMessage, colour, root = () => null, named = () => null }) {
+  const tone = (value, name = 'text', bold = false) => ink(value, name, colour, bold);
+  const first = value => fitWords(String(value ?? '').split('\n').find(line => line.trim()) ?? '', 48) || 'none';
+  // The vendor list is skipped when there is one vendor, the effort list when the vendor has
+  // no such setting. Each gives undefined when it is closed with Esc.
+  async function pickVendor(current = null) {
+    const vendors = botVendors();
+    if (vendors.length === 1) return vendors[0];
+    const picked = await listDialog('Runs on', vendors.map(vendor => tone(vendor.padEnd(8), 'text', true) + tone(VENDOR_NAMES[vendor], 'muted')), { selected: Math.max(0, vendors.indexOf(current)) });
+    return picked ? vendors[picked.index] : undefined;
+  }
+  // The first choice names no effort: the vendor's own, with the level when it is known.
+  async function pickEffort(vendor, current = null, model = null) {
+    const efforts = botEfforts(vendor);
+    if (!efforts.length) return null;
+    const theirs = ownEffort(vendor, model);
+    const picked = await listDialog('Effort', [tone(theirs ? `${theirs} · ${own(vendor)}` : own(vendor)), ...efforts.map(effort => tone(effort))], { selected: efforts.indexOf(current) + 1 });
+    return picked ? picked.index ? efforts[picked.index - 1] : null : undefined;
+  }
+  // The colour a bot's name shows in. The first choice names none: one is picked at random.
+  async function pickColor(current = null) {
+    const picked = await listDialog('Color', [tone('random'.padEnd(8), 'text', true) + tone('one no other bot has, while there is one', 'muted'), ...BOT_COLORS.map(color => tone(color, color, true))], { selected: BOT_COLORS.indexOf(current) + 1 });
+    return picked ? picked.index ? BOT_COLORS[picked.index - 1] : null : undefined;
+  }
+  // picked: the model the vendor's own choice turned out to be, when a run has reported it.
+  const modelHint = (vendor, picked = null) => `A model ${vendor} knows by name. Empty uses ${own(vendor)}${picked ? `: ${picked}` : ''}.`;
+  // The Model step checks a name the way the store does, so a name that cannot be saved is
+  // refused here and never under the instructions. It lists the names the vendor's own
+  // command line reports, narrowed to what is typed. A name that is not listed is asked
+  // about once and taken on a second Enter: a list goes stale, and a full model name must
+  // stay possible. The saved name is never asked about. A vendor with no known names has
+  // no list.
+  function modelStep(vendor, saved = '') {
+    const models = botModels(vendor), check = text => botModelProblem(vendor, text.trim());
+    if (!models.length) return { check };
+    const fine = name => !name || name === saved || models.some(row => row.name === name);
+    return { check, suggest: text => matchModels(models, text), warn: text => fine(text.trim()) ? null : `${text.trim()} is not a model ${vendor} lists.` };
+  }
+  // The Schedule step refuses a text /schedule cannot read, one that does not repeat, and
+  // one too long for the store, each with the store's own line. It lists three examples.
+  function scheduleStep() {
+    const long = text => text.trim().replace(/\s+/g, ' ').length > SCHEDULE_MAX ? `Keep the schedule under ${SCHEDULE_MAX} characters, such as every 1h.` : null;
+    return { check: text => botScheduleProblem(text) ?? long(text), suggest: text => matchModels(SCHEDULES, text) };
+  }
+  // The MCP servers step lists the servers Claude Code has, narrowed to the name being
+  // typed. Taking one keeps the names before it, and a name already typed is not listed
+  // again. A badly formed name is refused here. A name Claude Code does not have is asked
+  // about once and taken on a second Enter: the server may be set up later. A saved name is
+  // never asked about.
+  function serversStep(saved = []) {
+    const known = Object.keys(claudeServers(root())).map(name => ({ name, note: '' }));
+    const names = text => { try { return botServers(text); } catch { return []; } };
+    const step = { check: text => botServersProblem(text), warn: text => notSetUp(names(text).filter(name => !saved.includes(name) && !known.some(row => row.name === name))) };
+    if (!known.length) return step;
+    return { ...step, suggest: text => {
+      const [, head = '', last] = /^(.*[\s,])?([^\s,]*)$/.exec(text), taken = names(head);
+      return matchModels(known.filter(row => !taken.includes(row.name)), last).map(row => ({ ...row, value: head + row.name }));
+    } };
+  }
+  // One line, asked again with the reason above it until the save is taken. Esc changes nothing.
+  async function line(title, body, value, save, options = {}) {
+    for (let note = ''; ;) {
+      const answer = await prompt(title, note + body, value, options);
+      if (answer === null) return;
+      try { save(answer.trim()); return; } catch (error) { note = `${error.message}\n\n`; value = answer; }
+    }
+  }
+  // n or + New bot: a name, where it runs, its model and effort, when it runs by itself, its
+  // MCP servers and its colour, then its instructions. A bot made here works when it is
+  // written to; what it does with the work is in its instructions.
+  async function create() {
+    // A full store is said before anything is asked, not after the instructions are written.
+    const full = botRoomProblem(); if (full) throw new Error(full);
+    const name = (await prompt('New bot', 'Lowercase letters, digits or -, starting with a letter.\nYou write @name to ask it.', ''))?.trim().replace(/^@/, '');
+    if (!name) return null;
+    // A name the store would refuse is refused here, before anything else is asked.
+    const problem = botNameProblem(name); if (problem) throw new Error(problem);
+    const vendor = await pickVendor(); if (vendor === undefined) return null;
+    const model = await prompt('Model', modelHint(vendor), '', modelStep(vendor)); if (model === null) return null;
+    const effort = await pickEffort(vendor, null, model.trim() || null); if (effort === undefined) return null;
+    const schedule = await prompt('Schedule', SCHEDULE_HINT, '', scheduleStep()); if (schedule === null) return null;
+    const servers = await prompt('MCP servers', serversHint(vendor), '', serversStep()); if (servers === null) return null;
+    // random, the first choice, saves no colour: the store picks one.
+    const color = await pickColor(); if (color === undefined) return null;
+    let saved = null;
+    // A refused save keeps the editor open with the reason, and the status line says it too.
+    await editSetting(`Instructions · @${name}`, '', text => { try { saved = saveBot({ name, vendor, model: model.trim() || null, effort, works: true, schedule: schedule.trim() || null, mcp: servers, color, instructions: text }); } catch (error) { setMessage(error.message); throw error; } });
+    if (saved) setMessage(`Made @${name}. Write @${name} in a session to ask it.`);
+    return saved;
+  }
+  async function remove(name) {
+    if (!await yes(`Remove @${name}`, 'Its name and instructions are deleted.', 'y/N')) return false;
+    removeBot(name); setMessage(`Removed @${name}.`); return true;
+  }
+  // Enter on a bot: each row changes one thing and saves it.
+  async function open(name) {
+    const row = (label, value) => tone(label.padEnd(14), 'muted') + tone(value);
+    for (let selected = 0; ;) {
+      const bot = getBot(name); if (!bot) return;
+      const save = (change, options) => saveBot({ ...bot, ...change }, options), runs = saved => setMessage(`@${saved.name} runs on ${botRuns(saved)}.`);
+      const rows = [tone('Name'.padEnd(14), 'muted') + tone(bot.name, botColor(bot), true), row('Runs on', bot.vendor), row('Model', first(botModelText(bot, named))), row('Effort', botEffortText(bot)), row('Schedule', first(scheduleText(bot))), row('MCP servers', first(bot.mcp.join(', '))), row('About', first(bot.about)), row('Instructions', first(bot.instructions)), tone('Teammates can use it  ', 'muted') + tone(bot.shared ? 'yes' : 'no'), tone('Remove')];
+      // Color sits just above Remove, the last row.
+      const colorRow = rows.length - 1; rows.splice(colorRow, 0, tone('Color'.padEnd(14), 'muted') + tone(botColor(bot), botColor(bot), true));
+      const picked = await listDialog(`Bot @${bot.name}`, rows, { selected, notes: botNotes(bot, Object.keys(claudeServers(root()))) });
+      if (!picked) return;
+      selected = picked.index;
+      // A change the store refuses is said in the status line, and the bot stays open as it was.
+      try {
+        if (selected === colorRow) {
+          const color = await pickColor(botColor(bot));
+          if (color !== undefined) { const saved = save({ color: color ?? pickBotColor(listBots().filter(row => row.name !== bot.name), { not: botColor(bot) }) }); setMessage(`@${saved.name} is ${saved.color} now.`); }
+          continue;
+        }
+        if (selected === 0) await line(`Rename @${bot.name}`, 'Lowercase letters, digits or -, starting with a letter.', bot.name, value => {
+          const next = value.replace(/^@/, ''); if (next === bot.name) return;
+          const problem = botNameProblem(next, { previous: bot.name }); if (problem) throw new Error(problem);
+          save({ name: next }, { previous: bot.name }); name = next; setMessage(`@${bot.name} is now @${next}.`);
+        });
+        else if (selected === 1) {
+          // A model and an effort belong to their vendor, so a new vendor starts with its own.
+          // Helpers start on claude only, so a saved helpers model goes with the old vendor.
+          const vendor = await pickVendor(bot.vendor);
+          if (vendor && vendor !== bot.vendor) runs(save({ vendor, model: null, effort: null, subagents: null }));
+        } else if (selected === 2) await line('Model', modelHint(bot.vendor, bot.model ? null : named(bot)), bot.model ?? '', value => runs(save({ model: value || null })), modelStep(bot.vendor, bot.model ?? ''));
+        else if (selected === 3) {
+          if (!botEfforts(bot.vendor).length) { setMessage(`${bot.vendor} has no effort setting.`); continue; }
+          const effort = await pickEffort(bot.vendor, bot.effort, bot.model);
+          if (effort !== undefined) runs(save({ effort }));
+        } else if (selected === 4) await line('Schedule', SCHEDULE_HINT, bot.schedule ?? '', value => {
+          const saved = save({ schedule: value || null });
+          setMessage(saved.schedule ? `@${saved.name} runs by itself ${scheduleText(saved)}.` : `@${saved.name} does not run by itself.`);
+        }, scheduleStep());
+        else if (selected === 5) await line('MCP servers', serversHint(bot.vendor), bot.mcp.join(', '), value => {
+          const saved = save({ mcp: value });
+          setMessage(saved.mcp.length ? `@${saved.name}'s MCP servers: ${saved.mcp.join(', ')}.` : `@${saved.name} has no MCP servers.`);
+        }, serversStep(bot.mcp));
+        else if (selected === 6) await line('About', `One line on what @${bot.name} is for. Empty uses the first line of its instructions.`, bot.about, value => { save({ about: value }); setMessage('Saved.'); });
+        else if (selected === 7) await editSetting(`Instructions · @${bot.name}`, bot.instructions, text => save({ instructions: text }));
+        else if (selected === 8) { const saved = save({ shared: !bot.shared }); setMessage(saved.shared ? `Teammates can use @${bot.name}.` : `Only you can use @${bot.name}.`); }
+        else if (await remove(bot.name)) return;
+      } catch (error) { setMessage(error.message); }
+    }
+  }
+  return { create, open, remove };
+}