@elu-labs/elu 0.0.0-stage → 0.1.0

package/lib/install.mjs

@@ -0,0 +1,130 @@
+// Starts ELU Code. Started through npx, it first makes `elu` a command, so the next start is
+// one word, and it runs the installed copy when there is one: the copy npx fetched sits in
+// npm's cache, which npm may clear, so nothing lasting may name it.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { cleanPath, findBin, quote } from './util.mjs';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const PACKAGE = '@elu-labs/elu', COMMAND = 'elu';
+export const BY_HAND = `npm install --global ${PACKAGE}`;
+
+// npx keeps what it runs under _npx in npm's cache. Only such a copy offers to install the command.
+export const fromNpx = (folder = ROOT) => path.resolve(folder).split(path.sep).includes('_npx');
+
+// What npm is started with. npx exports the settings of the folder it was started in as
+// npm_config_* (that folder's .npmrc among them); none of those is passed on, so only the
+// user's own ~/.npmrc decides the registry and the global folder.
+const KEPT = /^(PATH|HOME|USER|LOGNAME|SHELL|LANG|LC_[A-Z]+|TERM|TMPDIR|HTTPS?_PROXY|NO_PROXY|https?_proxy|no_proxy|SSL_CERT_FILE|SSL_CERT_DIR|NODE_EXTRA_CA_CERTS)$/;
+export const npmEnv = (env = process.env) => Object.fromEntries(Object.entries(env).filter(([name]) => KEPT.test(name)));
+
+// npm beside the running node, else the first on PATH. npm's own launcher is a script, and
+// it is run with this node, not with whichever node PATH names.
+export function npmCommand(env = process.env, node = process.execPath) {
+  let file = null;
+  try { const beside = path.join(path.dirname(node), 'npm'); fs.accessSync(beside, fs.constants.X_OK); file = fs.realpathSync(beside); }
+  catch { file = findBin('npm', env); }
+  if (!file) return null;
+  return /\.c?js$/.test(file) ? [node, file] : [file];
+}
+const runNpm = (npm, args, options) => spawnSync(npm[0], [...npm.slice(1), ...args], { ...options, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+
+const manifest = folder => JSON.parse(fs.readFileSync(path.join(folder, 'package.json'), 'utf8'));
+// The package behind the first `elu` in these folders. npm links <prefix>/bin/elu to the
+// package's own bin folder; any other program of that name has no package of ours behind it.
+function look(folders) {
+  const file = findBin(COMMAND, { PATH: folders });
+  if (!file) return null;
+  try { const root = path.dirname(path.dirname(file)), { name, version } = manifest(root); return { file, root, name, version }; }
+  catch { return { file, root: null, name: null, version: null }; }
+}
+// True when this copy is the installed command: the package behind the first `elu` on PATH,
+// or behind ~/.local/bin/elu, where the first start puts it when npm's own folder cannot be
+// written. Only such a copy may be named by something lasting, a login item or a service. A
+// copy a package runner fetched is neither, wherever that runner keeps it.
+export function isInstalled({ root = ROOT, env = process.env, home = os.homedir() } = {}) {
+  let mine;
+  try { mine = fs.realpathSync(root); } catch { return false; }
+  return [cleanPath(env.PATH), path.join(home, '.local', 'bin')].some(folders => look(folders)?.root === mine);
+}
+// The npm prefix a copy was installed under, when it has npm's layout.
+function prefixOf(root) {
+  const prefix = path.resolve(root, '..', '..', '..', '..');
+  return path.join(prefix, 'lib', 'node_modules', ...PACKAGE.split('/')) === root ? prefix : null;
+}
+function writable(prefix) {
+  return ['bin', path.join('lib', 'node_modules')].every(part => {
+    let folder = path.join(prefix, part);
+    while (!fs.existsSync(folder) && path.dirname(folder) !== folder) folder = path.dirname(folder);
+    try { fs.accessSync(folder, fs.constants.W_OK | fs.constants.X_OK); return true; } catch { return false; }
+  });
+}
+// The copy npx runs can be older than the installed command: a version asked for by number,
+// or one an old npm kept. An older copy never replaces a newer command.
+function newer(installed, mine) {
+  const [a, b] = [installed, mine].map(value => String(value).split('-')[0].split('.').map(Number));
+  for (let i = 0; i < 3; i++) if ((a[i] || 0) !== (b[i] || 0)) return (a[i] || 0) > (b[i] || 0);
+  return false;
+}
+const shown = arg => /^[A-Za-z0-9_@%+=:,./-]+$/.test(arg) ? arg : quote(arg);
+const reason = result => result.error?.code === 'ETIMEDOUT' ? 'npm took too long'
+  : ((result.stderr ?? '').split('\n').map(line => line.replace(/^npm (error|ERR!)\s*/, '').trim()).find(Boolean) ?? result.error?.message ?? 'npm stopped').slice(0, 160);
+
+// Decides which copy a start through npx runs, installing the command first when that is
+// wanted. Returns the installed copy's folder, or null to run the copy npx fetched.
+// ELU_NO_INSTALL=1 installs nothing. What is installed is this package at this copy's
+// version, by name: nothing in the environment or the current folder can name another.
+export function prepare({ argv = [], env = process.env, interactive = false, write = () => {}, root = ROOT, home = os.homedir(), npm = npmCommand(env), run = runNpm } = {}) {
+  const version = manifest(root).version, local = path.join(home, '.local');
+  const first = look(env.PATH ?? ''), aside = first ? null : look(path.join(local, 'bin'));
+  const have = first ?? aside, wanted = interactive && argv.length === 0 && !env.ELU_NO_INSTALL;
+  const startup = /zsh$/.test(env.SHELL ?? '') ? '~/.zshrc' : /bash$/.test(env.SHELL ?? '') ? (process.platform === 'darwin' ? '~/.bash_profile' : '~/.bashrc') : "your shell's startup file";
+  const offPath = folder => `${folder} is not on your PATH yet. Add this line to ${startup} and open a new terminal: export PATH="${folder}:$PATH"\n`;
+  if (have?.name === PACKAGE && have.version === version) {
+    if (aside && wanted) write(offPath(path.join(local, 'bin')));
+    return have.root;
+  }
+  if (!wanted) return null;
+  if (have?.name === PACKAGE && newer(have.version, version)) { write(`The ${COMMAND} command on this computer is newer (${have.version}) than this copy (${version}), so it was left as it is.\n`); return null; }
+  if (first && first.name !== PACKAGE) { write(`Another program named ${COMMAND} is first on your PATH (${first.file}), so the ${COMMAND} command was not installed.\n`); return null; }
+  if (!npm) { write(`npm was not found, so the ${COMMAND} command was not installed. To install it yourself: ${BY_HAND}\n`); return null; }
+  // npm runs from the home folder with its own settings; see npmEnv.
+  const settings = { cwd: home, env: npmEnv(env) };
+  // Not `npm config get prefix`: npm will not print a value it takes for a secret, and it
+  // takes a folder name with an id in it for one.
+  const asked = run(npm, ['prefix', '--global'], { ...settings, timeout: 15000 });
+  const standard = asked.status === 0 ? asked.stdout.trim() : '';
+  // An update goes where the command already is. A first install goes to npm's global
+  // folder, or under ~/.local when that folder cannot be written.
+  const target = (have?.root && prefixOf(have.root)) ?? (path.isAbsolute(standard) && writable(standard) ? standard : local);
+  const args = ['install', '--global', ...(target === standard ? [] : ['--prefix', target]), '--ignore-scripts', `${PACKAGE}@${version}`];
+  write(`Installing the ${COMMAND} command: npm ${args.map(shown).join(' ')}\n`);
+  const result = run(npm, args, { ...settings, timeout: 180000 });
+  const made = look(path.join(target, 'bin'));
+  if (result.status !== 0 || made?.name !== PACKAGE || made.version !== version) {
+    write(`That did not work (${reason(result)}). ELU Code opens anyway. To install the command yourself: ${BY_HAND}\n`);
+    return null;
+  }
+  const now = look(env.PATH ?? '');
+  if (now && now.root !== made.root) write(`Installed, but another ${COMMAND} comes first on your PATH: ${now.file}\n`);
+  else write(`Next time, type: ${COMMAND}\n${now ? '' : offPath(path.join(target, 'bin'))}`);
+  return made.root;
+}
+
+export async function start({ argv = process.argv.slice(2), env = process.env, input = process.stdin, output = process.stdout } = {}) {
+  // npx puts node_modules/.bin of the current folder and of every folder above it first on
+  // PATH. Nothing is looked up or started before those entries are gone.
+  env.PATH = cleanPath(env.PATH);
+  let root = ROOT;
+  if (fromNpx()) {
+    try { root = prepare({ argv, env, interactive: Boolean(input.isTTY && output.isTTY), write: text => output.write(text) }) ?? ROOT; }
+    catch (error) { if (input.isTTY && output.isTTY && !argv.length) output.write(`The ${COMMAND} command was not installed (${error.message}). To install it yourself: ${BY_HAND}\n`); }
+  }
+  const entry = path.join(root, 'bin', 'elu-code.mjs');
+  // The app runs only as the program Node was asked to start, so it is named as that.
+  process.argv[1] = entry;
+  await import(pathToFileURL(entry).href);
+}

package/lib/kanban.mjs

@@ -0,0 +1,180 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { atomic, mkdir, noSymlinks, readJson, refuse } from './util.mjs';
+import { waitLock, taskTitle } from './state.mjs';
+import { botWork } from './bots.mjs';
+
+// One Kanban board per project. Cards you write wait in To do; a started card follows
+// its session (In progress while the lead works, Needs you when it stops), and Done
+// is where you put finished work. Sessions typed elsewhere appear on the board too.
+// The board lives with the project's sessions, not in its files, so it is never
+// committed by accident.
+
+export const COLUMNS = Object.freeze([['todo', 'To do'], ['progress', 'In progress'], ['needs', 'Needs you'], ['done', 'Done']]);
+const DONE_SHOWN = 20, QUIET_DAYS = 14;
+const file = repo => path.join(repo.state, 'kanban.json');
+const time = value => { const parsed = Date.parse(value); return Number.isFinite(parsed) ? parsed : 0; };
+const firstLine = value => String(value ?? '').split('\n').find(line => line.trim())?.trim() ?? '';
+
+export function readBoard(repo) {
+  const target = file(repo); noSymlinks(target);
+  if (!fs.existsSync(target)) return { cards: [], done: [], closed: {}, archived: [] };
+  const value = readJson(target);
+  const closed = value?.closed && typeof value.closed === 'object' && !Array.isArray(value.closed) ? Object.fromEntries(Object.entries(value.closed).filter(([, at]) => typeof at === 'string')) : {};
+  return {
+    cards: Array.isArray(value?.cards) ? value.cards.filter(card => typeof card?.id === 'string' && typeof card.text === 'string' && ['todo', 'started', 'done'].includes(card.column)) : [],
+    done: Array.isArray(value?.done) ? value.done.filter(id => typeof id === 'string') : [],
+    closed,
+    // The sessions the owner archived: they leave the board, while a session moved to Done on
+    // the board stays in Done. A board saved before this list did not tell the two apart, so
+    // every session it closed counts as archived.
+    archived: Array.isArray(value?.archived) ? value.archived.filter(id => typeof id === 'string') : Object.keys(closed),
+  };
+}
+const lastActivity = task => Math.max(time(task.createdAt), ...(task.runs ?? []).map(run => time(run.at)), ...(task.messages ?? []).map(row => time(row.at)));
+// An archived session (or one moved to Done) stays closed until it has newer activity: a
+// new message opens it again.
+export function sessionClosed(board, task) {
+  const at = board.done.includes(task.id) ? Date.parse(board.closed?.[task.id] ?? '') : NaN;
+  return Number.isFinite(at) && lastActivity(task) <= at && !['running', 'preparing'].includes(task.state);
+}
+export function closeSession(repo, id) {
+  return change(repo, board => { if (!board.done.includes(id)) board.done.push(id); if (!board.archived.includes(id)) board.archived.push(id); board.closed[id] = new Date().toISOString(); return id; });
+}
+// Brings an archived session back into the list.
+export function reopenSession(repo, id) {
+  return change(repo, board => { board.done = board.done.filter(row => row !== id); board.archived = board.archived.filter(row => row !== id); delete board.closed[id]; return id; });
+}
+function change(repo, edit) {
+  mkdir(repo.state);
+  const release = waitLock(repo, 'kanban', 200);
+  try { const board = readBoard(repo), result = edit(board); atomic(file(repo), board); return result; }
+  finally { release(); }
+}
+const find = (board, id) => board.cards.find(card => card.id === id) ?? refuse('That card no longer exists.');
+const checkText = text => { const value = String(text ?? '').trim(); if (!value || value.length > 16000) refuse('Write a task of 1 to 16000 characters.'); return value; };
+
+export function addCard(repo, text) {
+  const value = checkText(text), now = new Date().toISOString();
+  return change(repo, board => { if (board.cards.length >= 500) refuse('Keep at most 500 cards.'); const card = { id: `card-${crypto.randomUUID().slice(0, 8)}`, text: value, column: 'todo', requestId: null, taskId: null, createdAt: now, movedAt: now }; board.cards.push(card); return card; });
+}
+export function editCard(repo, id, text) {
+  const value = checkText(text);
+  return change(repo, board => { const card = find(board, id); if (card.column !== 'todo') refuse('Only a To do task can be edited. Its session has the conversation.'); card.text = value; return card; });
+}
+export function removeCard(repo, id) {
+  return change(repo, board => { const card = find(board, id); if (card.column === 'started') refuse('Move it to Done instead. Its session stays in Sessions.'); board.cards = board.cards.filter(value => value !== card); return card; });
+}
+// A started card remembers the request that started it; its session number arrives later.
+export function startCard(repo, id, requestId) {
+  return change(repo, board => { const card = find(board, id); if (card.column !== 'todo') refuse('Only a To do task can be started.'); Object.assign(card, { column: 'started', requestId, movedAt: new Date().toISOString() }); return card; });
+}
+export function linkCards(repo, requests) {
+  const board = readBoard(repo);
+  const missing = board.cards.filter(card => card.requestId && !card.taskId && requests.some(row => row.id === card.requestId && row.taskId));
+  if (!missing.length) return false;
+  change(repo, current => { for (const card of current.cards) { const row = card.requestId && !card.taskId && requests.find(value => value.id === card.requestId); if (row?.taskId) card.taskId = String(row.taskId); } });
+  return true;
+}
+// Done and back. A card that never started goes back to To do.
+export function setDone(repo, item, done) {
+  return change(repo, board => {
+    if (item.card) { const card = find(board, item.card.id); card.column = done ? 'done' : card.requestId || card.taskId ? 'started' : 'todo'; card.movedAt = new Date().toISOString(); return card; }
+    board.done = board.done.filter(id => id !== item.task.id); board.archived = board.archived.filter(id => id !== item.task.id); delete board.closed[item.task.id];
+    if (done) { board.done.push(item.task.id); board.closed[item.task.id] = new Date().toISOString(); }
+    return null;
+  });
+}
+
+function sessionColumn(task) {
+  if (['running', 'preparing'].includes(task.state)) return 'progress';
+  // A Task that waits for the owner's yes needs them, though its session rests as an answer leaves it.
+  if (task.plan?.state === 'proposed') return 'needs';
+  if (task.pr || task.kind === 'conversation' && task.state === 'answered') return 'done';
+  return 'needs';
+}
+const requestColumn = request => ['queued', 'starting', 'running'].includes(request.state) ? 'progress' : 'needs';
+function sessionDetail(task) {
+  if (task.state === 'running' || task.state === 'preparing') return botWork(task) ? `${botWork(task).agent} ${botWork(task).label}` : task.activeRole && task.activeRole !== 'lead' ? `${task.activeRole} reviewing` : 'working';
+  if (task.state === 'needs_input') return 'asks you';
+  if (task.state === 'ready') return 'ready to publish';
+  if (task.pr) return 'published';
+  return task.state.replace('_', ' ');
+}
+// A session with a Task (lib/plan.mjs) is on the board as that Task: its title, then where
+// it stands with the count of what is done, its priority and its severity. Under Needs you
+// what the session waits for comes first. A rejected Task leaves the session's own card.
+// The title is the model's text, and the screen shows it as typed.
+const taskOf = task => task?.plan && task.plan.state !== 'rejected' ? task.plan : null;
+function taskStands(plan, short) {
+  const steps = plan.subtasks?.length ?? 0, done = (plan.subtasks ?? []).filter(row => row.state === 'done').length, met = plan.met?.length ?? 0, goals = plan.objectives?.length ?? 0;
+  if (plan.state === 'proposed') return short ? 'to approve' : 'waits for your approval';
+  if (plan.state === 'done') return short ? `done ${met}/${goals}` : `done · ${met} of ${goals} objectives reported met`;
+  if (!steps) return short ? 'approved' : 'approved · no subtasks yet';
+  return short ? `${done}/${steps}` : `approved · ${done} of ${steps} subtasks done`;
+}
+const taskDetail = (plan, task, column) => [column === 'needs' && plan.state !== 'proposed' ? sessionDetail(task) : '', taskStands(plan, true), plan.priority, plan.severity].filter(Boolean).join(' · ');
+// The whole of it, for the row under the board while the card is selected.
+function taskNote(plan, task) {
+  const name = taskTitle(task), doing = plan.state === 'proposed' || task.state === 'answered' ? '' : sessionDetail(task);
+  return [`Task · ${taskStands(plan, false)}`, `${plan.priority} priority`, `${plan.severity} severity`, name && name !== plan.title ? `session: ${name}` : '', doing].filter(Boolean).join(' · ');
+}
+// As much of a Task card's detail as fits beside its title: whole parts from the start,
+// never half a word.
+export function fitDetail(detail, room) {
+  let text = '';
+  for (const part of String(detail ?? '').split(' · ')) { const next = text ? `${text} · ${part}` : part; if (next.length > room) break; text = next; }
+  return text;
+}
+// A title cut to its room: at a word, unless that leaves more than a third of the room
+// empty (a long word after a short one): then inside the word.
+function cutTitle(text, room) {
+  if (room < 2) return text.slice(0, Math.max(0, room));
+  const cut = text.slice(0, room - 1), space = cut.lastIndexOf(' '), words = space > 0 ? cut.slice(0, space).trimEnd() : cut;
+  return `${(words.length + 1) * 3 >= room * 2 ? words : cut.trimEnd()}…`;
+}
+// A Task's card in the width its column has, the title first. Whole parts of the detail go
+// beside the whole title as far as they fit, and a title that fits is never cut for them.
+// Only a title longer than the width is cut: the first part stays beside it while the title
+// keeps at least three fifths of the width, and otherwise the title has the line to itself.
+export function fitCard(title, detail, width) {
+  const text = String(title ?? '').replace(/\s/g, ' ').trimEnd();
+  if (text.length <= width) return { title: text, detail: fitDetail(detail, width - text.length - 2) };
+  const first = String(detail ?? '').split(' · ')[0], room = width - first.length - 2;
+  return first && room * 5 >= width * 3 ? { title: cutTitle(text, room), detail: first } : { title: cutTitle(text, width), detail: '' };
+}
+// The board's four columns for one project snapshot: { key, column, title, detail, card?, task?, request?, plan?, note? }.
+export function boardColumns(board, snapshot, now = Date.now()) {
+  // A teammate's question lives in its Chats thread; a handoff is a card like any session.
+  const tasks = (snapshot.tasks ?? []).filter(task => !['ask', 'review'].includes(task.origin?.kind)), queue = (snapshot.queue ?? []).filter(row => !row.origin && row.state !== 'done');
+  const linked = new Set(board.cards.flatMap(card => card.taskId ? [card.taskId] : [])), requested = new Set(board.cards.flatMap(card => card.requestId ? [card.requestId] : []));
+  const items = [];
+  for (const card of board.cards) {
+    const task = card.taskId && tasks.find(value => value.id === card.taskId), request = !task && card.requestId && queue.find(value => value.id === card.requestId);
+    const column = card.column === 'todo' ? 'todo' : card.column === 'done' ? 'done' : task ? sessionColumn(task) === 'done' ? 'needs' : sessionColumn(task) : request ? requestColumn(request) : 'needs';
+    // A card the owner wrote keeps its own words as the title; its session's Task shows beside them.
+    const plan = card.column === 'todo' ? null : taskOf(task);
+    const detail = card.column === 'todo' ? '' : plan ? taskDetail(plan, task, column) : task ? sessionDetail(task) : request ? request.state : card.column === 'done' ? 'done' : 'not started';
+    items.push({ key: card.id, column, title: firstLine(card.text), detail, card, task: task || null, request: request || null, ...(plan ? { plan, note: taskNote(plan, task) } : {}), order: column === 'done' ? -time(card.movedAt) : time(card.createdAt) });
+  }
+  for (const task of tasks) {
+    if (linked.has(task.id)) continue;
+    // An archived session is on no column, Done included, until a new message opens it again.
+    if ((board.archived ?? []).includes(task.id) && sessionClosed(board, task)) continue;
+    const last = Math.max(time(task.createdAt), ...(task.runs ?? []).map(run => time(run.at)), ...(task.messages ?? []).map(row => time(row.at)));
+    const reopened = board.done.includes(task.id) && board.closed?.[task.id] && !sessionClosed(board, task);
+    let column = board.done.includes(task.id) && !reopened ? 'done' : sessionColumn(task);
+    if (column !== 'progress' && now - last > QUIET_DAYS * 86400000 && column !== 'done') continue;
+    const plan = taskOf(task);
+    items.push({ key: `task-${task.id}`, column, title: plan ? plan.title : taskTitle(task), detail: plan ? taskDetail(plan, task, column) : sessionDetail(task), task, ...(plan ? { plan, note: taskNote(plan, task) } : {}), order: column === 'done' ? -last : last });
+  }
+  for (const request of queue) {
+    if (requested.has(request.id) || request.continuationTaskId) continue;
+    items.push({ key: request.id, column: requestColumn(request), title: firstLine(request.goal), detail: request.state === 'blocked' ? `blocked · ${firstLine(request.reason)}` : request.state, request, order: time(request.createdAt) });
+  }
+  return COLUMNS.map(([column, name]) => {
+    const rows = items.filter(item => item.column === column).sort((a, b) => a.order - b.order);
+    return { column, name, items: column === 'done' ? rows.slice(0, DONE_SHOWN) : rows };
+  });
+}

package/lib/mcp.mjs

@@ -0,0 +1,79 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mkdir, personalDirectory, readJson, refuse } from './util.mjs';
+import { APPROVAL_WAIT_SECONDS } from './modes.mjs';
+
+// Your own Claude Code MCP servers (claude mcp list), by name. A project's lead gets all of
+// them except the ones its settings turn off, and a teammate's run never gets any.
+const NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+const claudeFile = () => process.env.CLAUDE_CONFIG_DIR ? path.join(process.env.CLAUDE_CONFIG_DIR, '.claude.json') : path.join(os.homedir(), '.claude.json');
+export function claudeServers(root) {
+  let value;
+  try { value = readJson(claudeFile()); } catch { return {}; }
+  const servers = { ...(value?.mcpServers ?? {}), ...(root ? value?.projects?.[root]?.mcpServers ?? {} : {}) };
+  return Object.fromEntries(Object.entries(servers).filter(([name, server]) => NAME.test(name) && server && typeof server === 'object'));
+}
+export function checkServerName(name) {
+  if (typeof name !== 'string' || !NAME.test(name)) refuse('Use an MCP server name from claude mcp list.');
+  return name;
+}
+// Tells the lead which servers it has, and how the owner turns on one that is off.
+export function serverNote(root, on) {
+  const off = Object.keys(claudeServers(root)).filter(name => !on.includes(name));
+  return [
+    on.length ? `MCP servers on for you (tools named mcp__NAME__*): ${on.join(', ')}.` : '',
+    off.length ? `The owner's other Claude Code MCP servers are off for you: ${off.join(', ')}. When a request needs one of them, tell the owner to type /mcp on NAME in the message box, with that server's name, and then ask again.` : '',
+  ].filter(Boolean).join(' ');
+}
+// The approval relay: ELU Code's own stdio MCP server, started by Claude Code
+// from the same private config file as the owner's servers, named as the permission prompt
+// tool. Its arguments say which run it answers for; the state folder comes from the env.
+export const APPROVAL_SERVER = 'elu-code-approval', APPROVAL_TOOL = `mcp__${APPROVAL_SERVER}__approve`;
+const SERVER_SCRIPT = fileURLToPath(new URL('./approval-server.mjs', import.meta.url));
+export function approvalServer({ session, root, taskId, role, vendor, log, waitSeconds = APPROVAL_WAIT_SECONDS }) {
+  if (typeof session !== 'string' || !/^[A-Za-z0-9_-]{1,80}$/.test(session)) refuse('An approval relay needs a plain session id.');
+  if (typeof log !== 'string' || !path.isAbsolute(log)) refuse('An approval relay needs an absolute log path.');
+  const args = [SERVER_SCRIPT, '--session', session, '--root', String(root ?? ''), '--task', String(taskId ?? ''), '--role', String(role ?? 'lead'), '--vendor', String(vendor ?? 'claude'), '--log', log, '--wait', String(waitSeconds)];
+  return { command: process.execPath, args, env: { HOME: os.homedir(), ...(process.env.XDG_CONFIG_HOME ? { XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME } : {}) } };
+}
+// Server settings can hold tokens, so they go to a private file for one run, never to
+// the command line. The file lives in ELU Code's own state folder, which no session may
+// read; the shared temp folder is one a session can read. Its folder is named for the
+// process that made it, and the caller removes it when the run ends. approval: the relay
+// settings for this run (approvalServer), or null for a run that never asks.
+const OWN = /^mcp-([1-9][0-9]*)-[A-Za-z0-9]{6}$/, EARLIER = /^elu-code-mcp-[A-Za-z0-9]{6}$/, EARLIER_AGE_MS = 60000;
+const alive = pid => { try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
+const entries = dir => { try { return fs.readdirSync(dir); } catch { return []; } };
+const drop = folder => { try { if (fs.lstatSync(folder).isDirectory()) fs.rmSync(folder, { recursive: true, force: true }); } catch { /* Gone already. */ } };
+// Removes the settings a run left behind when its process died before it could: folders
+// of a process that is gone, and the folders an earlier release made in the temp folder.
+// It runs when ELU Code starts and never throws.
+export function sweepServers() {
+  const state = personalDirectory(), uid = process.getuid?.();
+  for (const name of entries(state)) {
+    const pid = Number(OWN.exec(name)?.[1] ?? 0);
+    if (pid && pid !== process.pid && !alive(pid)) drop(path.join(state, name));
+  }
+  const temps = [os.tmpdir()]; try { temps.push(fs.realpathSync(os.tmpdir())); } catch { /* Listed as named. */ }
+  for (const dir of new Set(temps)) {
+    for (const name of entries(dir).filter(name => EARLIER.test(name))) {
+      try { const stat = fs.lstatSync(path.join(dir, name)); if ((uid === undefined || stat.uid === uid) && Date.now() - stat.mtimeMs > EARLIER_AGE_MS) drop(path.join(dir, name)); } catch { /* Gone already. */ }
+    }
+  }
+}
+export function writeServers(names, root, { approval = null } = {}) {
+  const all = claudeServers(root), picked = {};
+  for (const name of names) {
+    if (name === APPROVAL_SERVER) refuse(`The MCP server name ${APPROVAL_SERVER} is reserved for ELU Code's approval relay.`);
+    if (!all[name]) refuse(`The MCP server ${name} is not set up in Claude Code. Run claude mcp list, or /mcp off ${name}.`);
+    picked[name] = all[name];
+  }
+  if (approval) picked[APPROVAL_SERVER] = approvalServer(approval);
+  const state = personalDirectory(); mkdir(state);
+  const folder = fs.mkdtempSync(path.join(state, `mcp-${process.pid}-`)); fs.chmodSync(folder, 0o700);
+  const file = path.join(folder, 'mcp.json');
+  fs.writeFileSync(file, JSON.stringify({ mcpServers: picked }), { mode: 0o600, flag: 'wx' });
+  return { file, folder, names: Object.keys(picked) };
+}

package/lib/memory.mjs

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// The owner's Claude Code memory for a folder: the notes Claude Code keeps in
+// ~/.claude/projects/<folder>/memory and loads into a new session there, plus the owner's
+// ~/.claude/CLAUDE.md and the folder's CLAUDE.md. The lead may not read ~/.claude, so a run
+// gets a private read-only copy of the memory folder, removed when the run ends.
+const LINES = 200, BYTES = 25000;
+const claudeDir = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+export const memorySlug = folder => folder.replace(/[^A-Za-z0-9]/g, '-');
+export const memoryFolder = root => path.join(claudeDir(), 'projects', memorySlug(root), 'memory');
+// Claude Code loads the first 200 lines of the index.
+export function clipNotes(text) {
+  const lines = String(text).split('\n'), kept = lines.slice(0, LINES).join('\n');
+  const clipped = Buffer.byteLength(kept) > BYTES ? Buffer.from(kept).subarray(0, BYTES).toString('utf8').replace(/�$/, '') : kept;
+  return clipped + (clipped.length < String(text).length ? '\n[Truncated.]' : '');
+}
+const readFile = file => { try { return fs.lstatSync(file).isFile() ? fs.readFileSync(file, 'utf8') : ''; } catch { return ''; } };
+export function copyMemory(root) {
+  const source = memoryFolder(root), user = readFile(path.join(claudeDir(), 'CLAUDE.md')), project = readFile(path.join(root, 'CLAUDE.md'));
+  let names = [];
+  try { names = fs.readdirSync(source, { withFileTypes: true }).filter(entry => entry.isFile() && entry.name.endsWith('.md')).map(entry => entry.name); } catch { /* No memory for this folder. */ }
+  if (!names.length && !user.trim() && !project.trim()) return null;
+  let folder = null, dir = null, index = '';
+  if (names.length) {
+    folder = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'elu-code-memory-'))); fs.chmodSync(folder, 0o700);
+    dir = path.join(folder, 'memory'); fs.mkdirSync(dir, { mode: 0o700 });
+    try {
+      for (const name of names) fs.writeFileSync(path.join(dir, name), readFile(path.join(source, name)), { mode: 0o600, flag: 'wx' });
+      index = names.includes('MEMORY.md') ? fs.readFileSync(path.join(dir, 'MEMORY.md'), 'utf8') : '';
+    } catch (error) { fs.rmSync(folder, { recursive: true, force: true }); throw error; }
+  }
+  return { folder, dir, index, user, project };
+}

package/lib/models.mjs

@@ -0,0 +1,144 @@
+// A session's model: a vendor's command line and the model name it is started with. Each
+// session keeps its own in its saved policy, so choosing one for a session changes no
+// other. The choices are the names each installed vendor lists, plus the ones the owner
+// added by name; those are kept in the personal folder (models.json), next to the bots.
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomic, findBin, hash, personalDirectory, readJson, refuse } from './util.mjs';
+import { approveSaved, trustedText } from './project-trust.mjs';
+import { CAPS, VENDORS, VENDOR_NAMES } from './vendors.mjs';
+import { parseConfig, validateConfig } from './config.mjs';
+import { stringifyYaml } from './yaml.mjs';
+import { assertPolicy } from './policy.mjs';
+import { pinnedConfig } from './checks.mjs';
+import { lock, readTask, saveTask, taskDir } from './state.mjs';
+import { isPeerRun } from './modes.mjs';
+import { botModelProblem } from './bots.mjs';
+import { botModels } from './bot-models.mjs';
+
+// What a new session runs on until the project names its own default.
+export const FIRST_MODEL = Object.freeze({ vendor: 'claude', model: 'opus' });
+const ADDED_MAX = 40;
+// The project config takes fewer characters in a model name than a bot does.
+const CONFIG_NAME = /^[A-Za-z0-9._:/-]{1,128}$/;
+const SHORT = { claude: 'Claude', codex: 'Codex', agy: 'Antigravity', grok: 'Grok' };
+
+// Vendors that can run a session, and the ones of them installed here.
+export const sessionVendors = () => VENDORS.filter(vendor => CAPS[vendor]?.lead);
+export const installedVendors = (env = process.env) => sessionVendors().filter(vendor => findBin(vendor, env));
+// What is wrong with a model name for a session on this vendor, or null. No name is the
+// vendor's own default.
+export function modelProblem(vendor, name) {
+  if (!sessionVendors().includes(vendor)) return `A session runs on one of: ${sessionVendors().join(', ')}.`;
+  if (name == null || name === '') return null;
+  return botModelProblem(vendor, name) ?? (CONFIG_NAME.test(String(name).trim()) ? null : 'A model name here has letters, digits, dots, colons, slashes or dashes.');
+}
+// A model in its saved shape, { vendor, model }, or a refusal the owner can act on.
+export function checkModel(value) {
+  const vendor = value?.vendor, model = value?.model == null || value.model === '' ? null : String(value.model).trim();
+  if (typeof vendor !== 'string') refuse('A model names its vendor.');
+  const problem = modelProblem(vendor, model); if (problem) refuse(problem);
+  return { vendor, model };
+}
+// "claude · opus": a model as a status line names it. A vendor alone is its own default.
+export const modelText = choice => [choice.vendor, choice.model].filter(Boolean).join(' · ');
+// What a vendor is called where a model has no name of its own.
+export const vendorShort = vendor => SHORT[vendor] ?? vendor;
+
+// The model in a config, and the one a new session of that project starts with: the one
+// the project names, else the first model on Claude, else the vendor's own default.
+export const configModel = config => ({ vendor: config.roles.lead.vendor, model: config.roles.lead.model ?? null });
+export function defaultModel(config) {
+  const { vendor, model } = configModel(config);
+  return model || vendor !== FIRST_MODEL.vendor ? { vendor, model } : { ...FIRST_MODEL };
+}
+// A copy of a config that runs on this model. A dollar budget and a command list stay only
+// where the vendor enforces them.
+export function withModel(config, choice) {
+  const { vendor, model } = checkModel(choice), next = structuredClone(config), lead = next.roles.lead;
+  lead.vendor = vendor;
+  if (model) lead.model = model; else delete lead.model;
+  lead.maxCostUsd = CAPS[vendor].budget ? lead.maxCostUsd ?? null : null;
+  if (!CAPS[vendor].commands) lead.commands = [];
+  return next;
+}
+
+export const modelsFile = () => path.join(personalDirectory(), 'models.json');
+// The models the owner added by name. A row that is no longer valid is left out.
+export function addedModels() {
+  let value; try { value = readJson(modelsFile()); } catch { return []; }
+  return (Array.isArray(value?.models) ? value.models : []).filter(row => typeof row?.name === 'string' && row.name && !modelProblem(row.vendor, row.name)).map(row => ({ vendor: row.vendor, name: row.name }));
+}
+export function rememberModel(vendor, name) {
+  const { model } = checkModel({ vendor, model: name });
+  if (!model) refuse('Name the model to add.');
+  const rows = addedModels();
+  if (!rows.some(row => row.vendor === vendor && row.name === model)) atomic(modelsFile(), { version: 1, models: [...rows, { vendor, name: model }].slice(-ADDED_MAX) });
+  return { vendor, model };
+}
+// Every model a session can be given here, as [{ name, vendor, model, note }]. name is what
+// the owner types: the model's own name, or vendor:name when two vendors share it. Claude's
+// own default is its first model, so only the other vendors have a row for theirs.
+export function modelChoices({ env = process.env } = {}) {
+  const rows = [], added = addedModels();
+  for (const vendor of installedVendors(env)) {
+    if (vendor !== FIRST_MODEL.vendor) rows.push({ vendor, model: null, note: 'its own default model' });
+    const listed = botModels(vendor, { env }).filter(row => !modelProblem(vendor, row.name));
+    for (const row of listed) rows.push({ vendor, model: row.name, note: row.note });
+    for (const row of added) if (row.vendor === vendor && !listed.some(item => item.name === row.name)) rows.push({ vendor, model: row.name, note: 'added by you' });
+  }
+  const plain = row => row.model ?? row.vendor, shared = name => rows.filter(row => plain(row) === name).length > 1 || VENDORS.includes(name);
+  return rows.map(row => ({ ...row, name: row.model && shared(row.model) ? `${row.vendor}:${row.model}` : plain(row) }));
+}
+// The model a typed name means: a listed name, vendor:name for any model of an installed
+// vendor, or a vendor alone for its default. Throws with a line that says what to type.
+export function findModel(text, { env = process.env } = {}) {
+  const typed = String(text ?? '').trim(), choices = modelChoices({ env }), pick = row => ({ vendor: row.vendor, model: row.model });
+  const listed = choices.find(row => row.name === typed) ?? choices.find(row => row.name.toLowerCase() === typed.toLowerCase());
+  if (listed) return pick(listed);
+  const at = typed.indexOf(':'), vendor = (at < 0 ? typed : typed.slice(0, at)).toLowerCase(), name = at < 0 ? '' : typed.slice(at + 1);
+  if (sessionVendors().includes(vendor)) {
+    if (!findBin(vendor, env)) throw new Error(`${VENDOR_NAMES[vendor]} is not installed or not on your PATH.`);
+    if (!name) return vendor === FIRST_MODEL.vendor ? { ...FIRST_MODEL } : { vendor, model: null };
+    const problem = modelProblem(vendor, name); if (problem) throw new Error(problem);
+    return { vendor, model: name };
+  }
+  const same = choices.filter(row => row.model === typed);
+  if (same.length > 1) throw new Error(`${typed} is on ${same.map(row => row.vendor).join(' and ')}. Type ${same.map(row => row.name).join(' or ')}.`);
+  throw new Error(choices.length ? `No model named ${typed.slice(0, 40)}. /model lists them; /model add adds one by name.` : 'No vendor command line is installed, so there is no model to choose yet.');
+}
+// The name a choice is typed as, for a list that marks the one in use.
+export function choiceName(choice, choices) {
+  const row = choices.find(item => item.vendor === choice.vendor && item.model === choice.model);
+  return row?.name ?? (choice.model ? `${choice.vendor}:${choice.model}` : choice.vendor);
+}
+
+// The model a session runs on is the one in its saved policy. Only a session that keeps
+// its own policy can change it; one pinned to a commit runs what that commit says.
+export const ownsPolicy = task => task?.mode === 'automatic' || task?.kind === 'conversation';
+// Sets a session's model from its next message. A turn in progress holds the session, so
+// the change waits for it to end.
+export function setSessionModel(repo, taskId, choice) {
+  let release;
+  try { release = lock(repo, `task-${taskId}`); }
+  catch (error) { if (error.message.includes('holds this lock')) refuse('Wait for the reply, or /stop, then choose the model.'); throw error; }
+  try {
+    const task = readTask(repo, taskId);
+    if (isPeerRun(task.origin)) refuse("A teammate's question keeps the model it started with.");
+    if (!ownsPolicy(task)) refuse('This session keeps the model of the commit it started from.');
+    const { config } = pinnedConfig(repo, task.base, { current: false, task });
+    const next = withModel(config, choice), text = stringifyYaml(next); parseConfig(text);
+    assertPolicy(next.roles.lead, { mode: 'ask' });
+    atomic(path.join(taskDir(repo, task.id), 'policy.yaml'), text); task.configHash = hash(text); saveTask(repo, task);
+    return task;
+  } finally { release(); }
+}
+// Sets the model new sessions of a project start with: the vendor and model in its config
+// file. proposed is the config a project with no file yet would be given.
+export function setDefaultModel(repo, choice, proposed) {
+  // The change starts from settings the owner approved, never from a file he has not.
+  const file = path.join(repo.root, '.elu-code/config.yaml'), approved = trustedText(repo.root, 'config.yaml');
+  const config = withModel(approved != null ? parseConfig(approved) : proposed, choice);
+  validateConfig(config); assertPolicy(config.roles.lead, { mode: 'ask' }); const text = stringifyYaml(config);
+  fs.mkdirSync(path.dirname(file), { recursive: true }); approveSaved(repo.root, 'config.yaml', text); atomic(file, text); return config;
+}