@elu-labs/elu 0.0.0-stage → 0.1.1

package/lib/agy-hook.mjs

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+
+// The PreToolUse hook every ELU Code launch of Antigravity CLI installs. agy's
+// own settings deny or ask per permission action; this hook covers what they cannot: web
+// search has no permission action, and the never list is matched on command text. It reads
+// the tool call on stdin and prints {"decision":"deny"|"ask","reason"}; no output means no
+// opinion, so agy's own permission flow decides. A deny also exits 2 with the reason on
+// stderr, the blocking convention hooks share. Anything unreadable denies. No imports from
+// lib/: agy starts this script for every matched tool call, so it stays small and fast.
+export const PROFILES = Object.freeze(['locked', 'ask', 'auto', 'full']);
+export const TOOLS = Object.freeze(['search_web', 'run_command', 'write_to_file', 'replace_file_content', 'multi_replace_file_content', 'generate_image', 'schedule', 'invoke_subagent', 'define_subagent']);
+// Which tool calls reach the hook in each profile; the hook decides from there.
+export const MATCHERS = Object.freeze({ locked: TOOLS.join('|'), ask: 'search_web|run_command', auto: TOOLS.join('|'), full: 'run_command' });
+// Push, tag, merge, deploy and publish by command text: a tripwire, not a boundary.
+// A command word ends where the word does: git merge-base and git tag-list are other
+// commands, as they are to the other vendors' rules. Anything else after the word still counts.
+const NEVER = [
+  String.raw`^git(?:\s+(?:-[cC]\s+\S+|--?\S+))*\s+(?:push|tag|merge)`, String.raw`^gh\s+pr\s+merge`, String.raw`^gh\s+release`,
+  String.raw`^(?:npm|pnpm|yarn|cargo)\s+publish`, String.raw`^(?:firebase|vercel|fly)\s+deploy`, String.raw`^gcloud\s+(?:run|app)\s+deploy`,
+  String.raw`^kubectl\s+apply`, String.raw`^terraform\s+apply`,
+].map(source => new RegExp(`${source}(?![\\w-])`));
+const deny = reason => ({ decision: 'deny', reason });
+const ask = reason => ({ decision: 'ask', reason });
+export function commandText(input) {
+  for (const key of ['CommandLine', 'command', 'cmd']) if (typeof input?.[key] === 'string') return input[key];
+  return input == null ? '' : typeof input === 'string' ? input : JSON.stringify(input);
+}
+export function neverListed(text) {
+  return String(text).split(/\s*(?:\|\||&&|;|\||\n)\s*/).some(part => { const segment = part.trim().replace(/^(?:sudo|env)\s+/, ''); return NEVER.some(rule => rule.test(segment)); });
+}
+// The decision for one tool call, or null for no opinion.
+export function decide(profile, event) {
+  const tool = typeof event?.tool_name === 'string' ? event.tool_name : null;
+  if (!PROFILES.includes(profile) || !tool) return deny('ELU Code could not read this tool call.');
+  if (profile === 'locked') return TOOLS.includes(tool) ? deny(`${tool} is not available in a read-only run.`) : null;
+  if (tool === 'run_command' && neverListed(commandText(event.tool_input))) return deny('Push, tag, merge, deploy and publish are never run by the model.');
+  if (tool === 'search_web') return profile === 'ask' ? ask('Web search needs your approval.') : profile === 'auto' ? deny('Web search is off in Approve for me.') : null;
+  if (profile === 'auto' && TOOLS.includes(tool)) return ask(`${tool} goes to the reviewer.`);
+  return null;
+}
+function main() {
+  const at = process.argv.indexOf('--profile'), profile = at > 0 ? process.argv[at + 1] : null;
+  let event = null;
+  try { event = JSON.parse(fs.readFileSync(0, 'utf8')); } catch { /* Unreadable: denied below. */ }
+  const verdict = decide(profile, event);
+  if (!verdict) return;
+  process.stdout.write(`${JSON.stringify(verdict)}\n`);
+  if (verdict.decision === 'deny') { process.stderr.write(`${verdict.reason}\n`); process.exitCode = 2; }
+}
+let direct = false;
+try { direct = Boolean(process.argv[1]) && pathToFileURL(fs.realpathSync(process.argv[1])).href === import.meta.url; } catch { /* Imported, or started another way. */ }
+if (direct) main();

package/lib/approval-server.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { approvalSummary, awaitDecision, requestApproval } from './approvals.mjs';
+import { APPROVAL_WAIT_SECONDS } from './modes.mjs';
+
+// The live approval relay for Claude Code: a stdio MCP server with one tool,
+// approve, named by --permission-prompt-tool. Claude calls it for every action its permission
+// mode would prompt for; the call becomes a request file the terminal answers, and the reply
+// is the one text block Claude expects. Newline-delimited JSON-RPC 2.0, no dependencies.
+// Every message is answered without blocking the read loop, so a ping arriving while an
+// approval waits is still answered, and an unknown method never hangs the run.
+export const SERVER_NAME = 'elu-code-approval', TOOL_NAME = 'approve';
+const DENIED = 'The owner declined this. Do not retry it another way. Finish without it and say what you could not do.';
+const ID_CHARS = /[^A-Za-z0-9_-]/g, PLAIN = /^[A-Za-z0-9_-]{1,80}$/;
+
+function options(argv) {
+  const out = { session: null, root: null, task: null, role: null, vendor: null, log: null, wait: APPROVAL_WAIT_SECONDS, progress: 60 };
+  for (let i = 0; i < argv.length; i += 2) {
+    const name = argv[i].replace(/^--/, ''), value = argv[i + 1];
+    if (!Object.hasOwn(out, name) || value === undefined) throw new Error(`Unknown or incomplete option: ${argv[i]}`);
+    out[name] = ['wait', 'progress'].includes(name) ? Number(value) : value;
+  }
+  if (!PLAIN.test(out.session ?? '')) throw new Error('The approval server needs a plain --session id.');
+  if (!(out.wait > 0) || !(out.progress > 0)) throw new Error('--wait and --progress are positive seconds.');
+  if (out.log && !path.isAbsolute(out.log)) throw new Error('--log must be an absolute path.');
+  return out;
+}
+const timeoutText = wait => `No answer from the owner within ${Math.max(1, Math.round(wait / 60))} minutes. Do not retry it another way; say what you need.`;
+const TOOL = { name: TOOL_NAME, description: 'Asks the owner of this session to allow or deny a tool call.', inputSchema: { type: 'object', properties: { tool_name: { type: 'string' }, input: { type: 'object' }, tool_use_id: { type: 'string' } }, required: ['tool_name', 'input'] } };
+
+export async function serve({ argv = process.argv.slice(2), input = process.stdin, output = process.stdout } = {}) {
+  const opts = options(argv);
+  const send = value => { try { output.write(`${JSON.stringify({ jsonrpc: '2.0', ...value })}\n`); } catch { /* Claude closed the pipe; the run is over. */ } };
+  const reply = (id, result) => send({ id, result }), fail = (id, code, message) => send({ id, error: { code, message } });
+  let calls = 0;
+  const record = row => { if (opts.log) { try { fs.appendFileSync(opts.log, `${JSON.stringify(row)}\n`, { mode: 0o600 }); } catch { /* The decision still reaches Claude. */ } } };
+  async function approve(id, params) {
+    const args = params?.arguments ?? {};
+    const tool = typeof args.tool_name === 'string' && args.tool_name.trim() ? args.tool_name.slice(0, 120) : 'unknown';
+    const use = String(args.tool_use_id ?? '').replace(ID_CHARS, '').slice(0, 78) || `call-${++calls}`;
+    const approvalId = `${opts.session}-${use}`;
+    let summary;
+    try { ({ summary } = requestApproval({ id: approvalId, root: opts.root, taskId: opts.task, role: opts.role, vendor: opts.vendor, tool, input: args.input, waitSeconds: opts.wait })); }
+    catch (error) {
+      // The same call asked twice waits on the first request; anything else is answered as a denial.
+      if (!/already requested/.test(error.message)) { record({ id: approvalId, tool, summary: approvalSummary(tool, args.input), decision: 'deny', at: new Date().toISOString() }); return reply(id, text({ behavior: 'deny', message: DENIED })); }
+      summary = approvalSummary(tool, args.input);
+    }
+    const token = params?._meta?.progressToken; let ticks = 0;
+    const timer = setInterval(() => { if (token !== undefined) send({ method: 'notifications/progress', params: { progressToken: token, progress: ++ticks, message: `Waiting for the owner: ${summary}` } }); }, opts.progress * 1000);
+    let decision;
+    try { decision = await awaitDecision(approvalId, { waitSeconds: opts.wait }); } catch { decision = 'deny'; }
+    finally { clearInterval(timer); }
+    record({ id: approvalId, tool, summary, decision, at: new Date().toISOString() });
+    reply(id, text(decision === 'allow' ? { behavior: 'allow' } : { behavior: 'deny', message: decision === 'timeout' ? timeoutText(opts.wait) : DENIED }));
+  }
+  const text = value => ({ content: [{ type: 'text', text: JSON.stringify(value) }] });
+  function handle(row) {
+    const { id, method, params } = row;
+    if (method === 'initialize') return reply(id, { protocolVersion: params?.protocolVersion ?? '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: SERVER_NAME, version: '1' } });
+    if (method === 'ping') return reply(id, {});
+    if (method === 'tools/list') return reply(id, { tools: [TOOL] });
+    if (method === 'tools/call') return params?.name === TOOL_NAME ? approve(id, params) : fail(id, -32602, `Unknown tool: ${String(params?.name ?? '').slice(0, 60)}`);
+    return fail(id, -32601, 'Method not found');
+  }
+  const lines = readline.createInterface({ input });
+  lines.on('line', line => {
+    if (!line.trim()) return;
+    let row; try { row = JSON.parse(line); } catch { return fail(null, -32700, 'Parse error'); }
+    if (!row || typeof row !== 'object' || Array.isArray(row)) return fail(null, -32600, 'Invalid request');
+    if (row.method === undefined) return; // A response to a notification of ours: nothing to do.
+    if (row.id === undefined || row.id === null) return; // Notifications (initialized, cancelled) need no reply.
+    handle(row);
+  });
+  await new Promise(resolve => { lines.once('close', resolve); input.once('end', resolve); });
+}
+
+if (process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  process.stdout.on('error', () => process.exit(0));
+  try { await serve(); process.exit(0); }
+  catch (error) { process.stderr.write(`${error.message}\n`); process.exit(2); }
+}

package/lib/approvals.mjs

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { mkdir, noSymlinks, personalDirectory, readJson, refuse } from './util.mjs';
+import { APPROVAL_WAIT_SECONDS } from './modes.mjs';
+
+// The approval file protocol. A vendor relay (the Claude MCP server, an ACP client) writes
+// a request under <personalDirectory()>/approvals and waits; the terminal answers it. Both
+// files are written once, so the first writer wins and nothing is overwritten.
+const ID = /^[A-Za-z0-9_-]{1,160}$/;
+const INPUT_LIMIT = 4096, POLL_MS = 300;
+// A summary of this length was cut: what it asks cannot be read whole.
+export const SUMMARY_LIMIT = 200;
+const control = new RegExp(`[\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f${String.fromCodePoint(0x200b)}-${String.fromCodePoint(0x200f)}${String.fromCodePoint(0x2028)}-${String.fromCodePoint(0x202e)}${String.fromCodePoint(0x2060)}-${String.fromCodePoint(0x206f)}${String.fromCodePoint(0xfeff)}]`, 'g');
+const clean = value => String(value ?? '').replace(control, '');
+const checkId = id => { if (typeof id !== 'string' || !ID.test(id)) refuse('Invalid approval ID.'); return id; };
+
+export function approvalsDir() {
+  const dir = path.join(personalDirectory(), 'approvals'); mkdir(dir);
+  if ((fs.statSync(dir).mode & 0o777) !== 0o700) fs.chmodSync(dir, 0o700);
+  return dir;
+}
+const requestFile = id => path.join(approvalsDir(), `${id}.json`);
+const answerFile = id => path.join(approvalsDir(), `${id}.answer.json`);
+// A file is written whole under another name and then linked to its own, so a reader in
+// another process never finds half of one, and the first writer still wins. The list
+// skips the other name (it does not end in .json) and removes one a dead writer left.
+const DRAFT = /^\.[A-Za-z0-9_.-]{1,180}\.[0-9a-f]{12}\.tmp$/, DRAFT_AGE_MS = 60000, NO_LINKS = ['EPERM', 'ENOTSUP', 'EOPNOTSUPP', 'ENOSYS'];
+function writeOnce(file, value) {
+  noSymlinks(file);
+  const text = `${JSON.stringify(value, null, 2)}\n`, draft = path.join(path.dirname(file), `.${path.basename(file)}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  fs.writeFileSync(draft, text, { flag: 'wx', mode: 0o600 });
+  try { fs.linkSync(draft, file); return true; }
+  catch (error) {
+    if (error.code === 'EEXIST') return false;
+    if (!NO_LINKS.includes(error.code)) throw error;
+    // A file system without hard links: written in place, as before.
+    try { fs.writeFileSync(file, text, { flag: 'wx', mode: 0o600 }); return true; } catch (again) { if (again.code === 'EEXIST') return false; throw again; }
+  } finally { remove(draft); }
+}
+// Model output is clipped before it reaches disk or a screen: 4 KB of input, 200 characters of summary.
+function clip(input) {
+  if (input === undefined) return null;
+  const text = typeof input === 'string' ? input : JSON.stringify(input) ?? 'null';
+  return text.length <= INPUT_LIMIT ? input : { clipped: true, text: text.slice(0, INPUT_LIMIT) };
+}
+const relativeToHome = (value, home) => { const root = home ?? os.homedir(); const text = String(value); return text === root ? '~' : text.startsWith(`${root}/`) ? `~/${text.slice(root.length + 1)}` : text; };
+export function approvalSummary(tool, input, { home, title } = {}) {
+  const field = name => typeof input?.[name] === 'string' ? input[name] : '';
+  let text;
+  if (title) text = String(title);
+  else if (tool === 'Bash') text = `Run: ${field('command')}${input?.dangerouslyDisableSandbox === true ? ' outside the sandbox' : ''}`;
+  else if (['Edit', 'Write', 'MultiEdit', 'NotebookEdit'].includes(tool)) text = `Edit: ${relativeToHome(field('file_path') || field('notebook_path'), home)}`;
+  else if (tool === 'WebFetch') text = `Open: ${field('url')}`;
+  else if (tool === 'WebSearch') text = `Search: ${field('query')}`;
+  else text = `Use ${clean(tool) || 'a tool'}`;
+  return clean(text).replace(/\s+/g, ' ').trim().slice(0, SUMMARY_LIMIT);
+}
+export function requestApproval({ id, root, taskId, role, vendor, tool, input, title = null, waitSeconds = APPROVAL_WAIT_SECONDS, pid = process.pid }) {
+  checkId(id);
+  if (typeof tool !== 'string' || !tool.trim() || tool.length > 120) refuse('An approval names its tool.');
+  if (!Number.isFinite(waitSeconds) || waitSeconds <= 0) refuse('An approval needs a positive wait.');
+  const at = Date.now(), summary = approvalSummary(tool, input, { title });
+  const record = { version: 1, id, root: root ?? null, taskId: taskId == null ? null : String(taskId), role: role ?? null, vendor: vendor ?? null, tool: clean(tool).slice(0, 120), input: clip(input), title: title == null ? null : clean(title).slice(0, SUMMARY_LIMIT), summary, pid, at: new Date(at).toISOString(), expiresAt: new Date(at + waitSeconds * 1000).toISOString() };
+  if (!writeOnce(requestFile(id), record)) refuse('This approval was already requested.');
+  return { id, summary };
+}
+// true when the answer was recorded; false when it was already answered or the request is gone.
+export function answerApproval(id, decision) {
+  checkId(id);
+  if (!['allow', 'deny'].includes(decision)) refuse('Answer allow or deny.');
+  const request = requestFile(id); noSymlinks(request);
+  if (!fs.existsSync(request)) return false;
+  return writeOnce(answerFile(id), { id, decision, at: new Date().toISOString() });
+}
+function readAnswer(id) {
+  const file = answerFile(id); noSymlinks(file);
+  if (!fs.existsSync(file)) return null;
+  try { const value = readJson(file); return ['allow', 'deny'].includes(value?.decision) ? value.decision : 'deny'; } catch { return 'deny'; }
+}
+const remove = file => { try { fs.rmSync(file, { force: true }); } catch { /* Pruned already. */ } };
+// Polls for the owner's answer, then removes both files, the request first: with the answer
+// gone and the request still there, a list made in between would show it as waiting again.
+// An abort stops the wait.
+export async function awaitDecision(id, { waitSeconds = APPROVAL_WAIT_SECONDS, signal } = {}) {
+  checkId(id);
+  const until = Date.now() + waitSeconds * 1000;
+  try {
+    for (;;) {
+      signal?.throwIfAborted();
+      const decision = readAnswer(id);
+      if (decision) return decision;
+      if (Date.now() >= until) return 'timeout';
+      await new Promise(resolve => { const timer = setTimeout(resolve, Math.min(POLL_MS, Math.max(1, until - Date.now()))); signal?.addEventListener('abort', () => { clearTimeout(timer); resolve(); }, { once: true }); });
+    }
+  } finally { remove(requestFile(id)); remove(answerFile(id)); }
+}
+const alive = pid => { try { process.kill(pid, 0); return true; } catch (error) { return error.code === 'EPERM'; } };
+// Requests still waiting for the owner, oldest first. Entries whose relay died or whose
+// wait has passed are removed, so a crashed run leaves nothing to answer.
+export function pendingApprovals({ root, taskId } = {}) {
+  const dir = approvalsDir(), now = Date.now(), rows = [], names = fs.readdirSync(dir);
+  for (const name of names.filter(name => DRAFT.test(name))) {
+    try { if (now - fs.lstatSync(path.join(dir, name)).mtimeMs > DRAFT_AGE_MS) remove(path.join(dir, name)); } catch { /* Linked and removed by its writer. */ }
+  }
+  for (const name of names.filter(name => name.endsWith('.json') && !name.endsWith('.answer.json'))) {
+    const id = name.slice(0, -5); if (!ID.test(id)) continue;
+    let record; try { record = readJson(path.join(dir, name)); } catch { remove(path.join(dir, name)); continue; }
+    if (!Number.isInteger(record?.pid) || !alive(record.pid) || !(Date.parse(record.expiresAt) > now)) { remove(path.join(dir, name)); remove(answerFile(id)); continue; }
+    // Decided in the meantime: its request was removed after it was read above.
+    if (fs.existsSync(answerFile(id)) || !fs.existsSync(path.join(dir, name))) continue;
+    if (root !== undefined && record.root !== root) continue;
+    if (taskId !== undefined && record.taskId !== String(taskId)) continue;
+    rows.push({ id, root: record.root, taskId: record.taskId, role: record.role, vendor: record.vendor, tool: record.tool, summary: clean(record.summary).slice(0, SUMMARY_LIMIT), at: record.at, expiresAt: record.expiresAt });
+  }
+  return rows.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+}
+// A run's approval log: one JSON row per line, { id, tool, summary, decision, at }. Bad lines are skipped.
+export function readApprovalLog(file) {
+  noSymlinks(file); if (!fs.existsSync(file)) return [];
+  const rows = [];
+  for (const line of fs.readFileSync(file, 'utf8').split('\n').slice(0, 1000)) {
+    if (!line.trim()) continue;
+    try { const row = JSON.parse(line); if (row && typeof row === 'object' && !Array.isArray(row)) rows.push({ id: clean(row.id).slice(0, 160), tool: clean(row.tool).slice(0, 120), summary: clean(row.summary).slice(0, SUMMARY_LIMIT), decision: ['allow', 'deny', 'timeout'].includes(row.decision) ? row.decision : 'deny', at: typeof row.at === 'string' ? row.at : null }); } catch { /* Skipped. */ }
+  }
+  return rows;
+}

package/lib/awake.mjs

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { atomic, mkdir, noSymlinks, readJson } from './util.mjs';
+import { waitLock } from './state.mjs';
+import { personalDirectory } from './usage.mjs';
+import { processIdentity } from './process.mjs';
+import { listSchedules } from './schedules.mjs';
+import { conductorStatus } from './conductor.mjs';
+
+// While an agent works or a schedule is on, caffeinate -i keeps the Mac from sleeping when
+// idle. The display still sleeps and locks as set. One caffeinate serves every terminal,
+// the conductor and the scheduler. Its process is recorded, so whoever sees nothing left
+// to do stops it.
+const BIN = '/usr/bin/caffeinate';
+const record = () => path.join(personalDirectory(), 'caffeinate.json');
+
+export function keepAwake(wanted, { platform = process.platform, bin = BIN, start = spawn, stop = pid => process.kill(pid, 'SIGTERM') } = {}) {
+  if (platform !== 'darwin' || !fs.existsSync(bin)) return false;
+  // Tests use their own start and stop, and never keep the real computer awake.
+  if (process.env.NODE_TEST_CONTEXT && start === spawn) return false;
+  mkdir(personalDirectory());
+  const release = waitLock({ state: personalDirectory() }, 'caffeinate', 100);
+  try {
+    const file = record(); noSymlinks(file);
+    let saved = null; try { saved = fs.existsSync(file) ? readJson(file) : null; } catch { saved = null; }
+    const running = Boolean(saved?.identity) && processIdentity(saved.pid) === saved.identity;
+    if (wanted && !running) {
+      const child = start(bin, ['-i'], { detached: true, stdio: 'ignore' }); child.unref?.();
+      atomic(file, { pid: child.pid, identity: processIdentity(child.pid), startedAt: new Date().toISOString() });
+      return true;
+    }
+    if (!wanted && running) { try { stop(saved.pid); } catch { /* It already ended. */ } }
+    if (!wanted && saved) fs.rmSync(file, { force: true });
+    return wanted;
+  } finally { release(); }
+}
+// Busy means the conductor has work, or a schedule is on. busy overrides the first part
+// for the conductor itself.
+export function refreshAwake({ busy, ...options } = {}) {
+  let working = busy;
+  if (working === undefined) { try { working = conductorStatus().runs.length > 0; } catch { working = false; } }
+  let scheduled = false; try { scheduled = listSchedules().some(row => row.enabled); } catch { /* Unreadable schedules keep nothing awake. */ }
+  try { return keepAwake(working || scheduled, options); } catch { return false; }
+}

package/lib/board.mjs

@@ -0,0 +1,261 @@
+import { relativeTime, remote, peerName, threadWho, fitWords } from './terminal-visuals.mjs';
+import { untilText } from './schedules.mjs';
+import { botWork } from './bots.mjs';
+import { taskTitle } from './state.mjs';
+
+// One row per agent run, waiting question, queued request, or recent result, across
+// every project. Rows needing the owner come first, then live work, then the queue.
+const FINISHED = ['answered', 'ready', 'unverified', 'blocked', 'stopped'];
+const DAY = 24 * 60 * 60 * 1000;
+const time = value => { const parsed = Date.parse(value); return Number.isFinite(parsed) ? parsed : 0; };
+const clock = ms => { const seconds = Math.max(0, Math.floor(ms / 1000)); return seconds < 3600 ? `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, '0')}` : `${Math.floor(seconds / 3600)}h${String(Math.floor(seconds % 3600 / 60)).padStart(2, '0')}`; };
+const firstLine = value => String(value ?? '').split('\n').find(line => line.trim())?.trim() ?? '';
+function cost(task) {
+  const known = (task.runs ?? []).filter(run => Number.isFinite(run.costUsd));
+  return known.length ? `${known.length < task.runs.length ? '≥' : ''}$${known.reduce((sum, run) => sum + run.costUsd, 0).toFixed(2)}` : '-';
+}
+// The newest thing a session did: its latest activity row that carries a step.
+function latestStep(project, id) {
+  for (let index = project.activity.length - 1; index >= 0; index--) {
+    const row = project.activity[index];
+    if (typeof row.step === 'string' && String(row.taskId) === String(id)) return firstLine(row.step);
+  }
+  return '';
+}
+function working(task) {
+  if (task.state === 'preparing') return { agent: 'lead', label: 'preparing' };
+  if (!task.activeRole) return { agent: 'checks', label: 'checks' };
+  if (task.activeRole === 'lead') return { agent: 'lead', label: task.kind === 'conversation' ? 'answering' : 'editing' };
+  return botWork(task) ?? { agent: task.activeRole, label: 'reviewing' };
+}
+function outcome(task) {
+  const checks = task.evidence?.results, passed = checks?.filter(row => row.status === 'passed').length;
+  if (task.state === 'ready') return `checks ${checks ? `${passed}/${checks.length}` : '-'} · review ${task.reviewStatus ?? '-'}`;
+  if (task.state === 'unverified') return 'edits not verified · /publish runs the checks first';
+  if (task.state === 'answered') return firstLine((task.reply ?? task.result)?.summary) || firstLine(task.goal);
+  return firstLine(task.error?.message) || firstLine(task.goal);
+}
+// Peer work that needs the owner sits with the questions in group 0. An incoming message
+// (question, review or task) waits in the peer daemon's files and arrives through
+// peerItems(); an older one may still be a saved request (state waiting, with an origin).
+// Held replies and agent drafts live only with the daemon.
+// Asks and reviews from a teammate; a handoff becomes a session of its own.
+export const peerQuestion = origin => ['ask', 'review'].includes(origin?.kind);
+const ORIGIN = { ask: ['ASK', 'Question'], review: ['REVIEW', 'Review their diff'], handoff: ['TASK', 'Task'] };
+function incoming(project, request, item, now) {
+  const who = peerName(request.origin.name, request.origin.peer), [label, lead] = ORIGIN[request.origin.kind] ?? ORIGIN.ask;
+  const text = request.origin.kind === 'review' ? '' : remote(request.context ?? item?.text, 400, { trusted: item?.trusted === true });
+  return { kind: 'request', root: project.root, project: project.name, id: '', request, item, agent: who, label: `${label} ${who}`, group: 0, order: time(request.createdAt), now: text ? `${lead} · ${text}` : lead, text: text || lead, time: relativeTime(request.createdAt, now), cost: '-' };
+}
+function peerRow(item, online, now) {
+  const who = threadWho(item), text = remote(item.text, 400, { trusted: item.trusted === true }), at = time(item.at);
+  const base = { kind: 'peer', item, root: typeof item.root === 'string' ? item.root : '', project: remote(item.project, 40) || '-', id: '', agent: who, cost: '-', time: relativeTime(item.at, now) };
+  if (item.kind === 'incoming') { const [label, lead] = ORIGIN[item.request ?? item.origin?.kind] ?? ORIGIN.ask; return { ...base, label: `${label} ${who}`, group: 0, order: at, now: text ? `${lead} · ${text}` : lead, text: text || lead }; }
+  if (item.kind === 'held') return { ...base, label: `REPLY ${who}`, group: 0, order: at, now: `Reply ready to send · ${text}`, text };
+  if (item.kind === 'draft') return { ...base, label: `SEND ${who}?`, group: 0, order: at, now: `Your model wants to ask · ${text}`, text };
+  if (item.kind === 'asked') return { ...base, label: 'asked', group: 2, order: 3e13 + at, now: item.team || online.has(item.peer) ? text : `${who} offline · will retry` };
+  if (['answer', 'expired', 'rejected'].includes(item.kind) && now - at < DAY) return { ...base, label: item.kind, group: 3, order: -at, now: item.kind === 'answer' ? `Answer · ${text}` : text || `Ask ${item.kind}`, text: text || `Ask ${item.kind}` };
+  return null;
+}
+export const peerDecision = row => row && (row.kind === 'peer' ? ['incoming', 'held', 'draft'].includes(row.item.kind) : row.kind === 'request' && Boolean(row.request.origin) && row.request.state === 'waiting');
+// An incoming message from a teammate: y accepts it, n declines.
+export const peerIncoming = row => peerDecision(row) && (row.kind === 'request' || row.item.kind === 'incoming');
+// A live approval the lead waits on: its summary reads "Run: npm install".
+// The row says "wants to run: npm install".
+const wants = summary => String(summary ?? '').replace(/^(Run|Edit|Open|Search|Use)\b/, verb => verb.toLowerCase());
+function approvalRow(approval, projects, now) {
+  const root = typeof approval.root === 'string' ? approval.root : '', name = projects.find(project => project.root === root)?.name ?? (root ? root.split('/').filter(Boolean).at(-1) : null) ?? '-';
+  const text = wants(approval.summary) || 'use a tool';
+  return { kind: 'approval', root, project: name, id: approval.taskId ?? '', approval, agent: approval.role ?? 'lead', label: 'WANTS', group: 0, order: time(approval.at), now: text, text, time: relativeTime(approval.at, now), cost: '-' };
+}
+// Finished work stays listed for `recent` ms (a day by default); peer threads for a day.
+// approvals: pendingApprovals() rows, each waiting for y or n.
+// archived: also list the sessions the owner archived, last, under their own heading.
+export function boardRows(projects, now = Date.now(), { items = [], online = new Set(), recent: window = DAY, schedules = [], approvals = [], archived = false, timed = {} } = {}) {
+  const rows = [], matched = new Set();
+  items = Array.isArray(items) ? items.filter(item => item && typeof item === 'object' && typeof item.id === 'string') : [];
+  // A lead that waits for an allow or deny is not working. Its session's own row moves to
+  // Needs you and says what it wants: the session is listed once, with no spinner, and
+  // keeps its place under the cursor. An approval with no session row gets a row of its own.
+  const pending = (Array.isArray(approvals) ? approvals : []).filter(approval => approval && typeof approval.id === 'string'), held = new Set();
+  for (const project of projects) {
+    if (project.unavailable) continue;
+    for (const task of project.tasks ?? []) {
+      // A teammate's question is answered in its Chats thread, not as a session.
+      if (peerQuestion(task.origin)) continue;
+      if (project.closed?.includes(task.id)) {
+        if (!archived) continue;
+        const at = Math.max(time(task.createdAt), ...(task.runs ?? []).map(run => time(run.at)), ...(task.messages ?? []).map(row => time(row.at)));
+        rows.push({ kind: 'task', root: project.root, project: project.name, id: task.id, task, cost: cost(task), agent: '-', label: 'archived', archived: true, group: 5, order: -at, now: outcome(task), time: relativeTime(new Date(at).toISOString(), now) });
+        continue;
+      }
+      // timed: the bots of this session that run on a schedule (botSchedulesShown), when it has any.
+      const base = { kind: 'task', root: project.root, project: project.name, id: task.id, task, cost: cost(task), ...(task.origin ? { agent: peerName(task.origin.name, task.origin.peer) } : {}), ...(timed[project.root]?.[task.id] ? { timed: timed[project.root][task.id] } : {}) };
+      const last = Math.max(time(task.createdAt), ...(task.runs ?? []).map(run => time(run.at)), ...(task.messages ?? []).map(row => time(row.at)));
+      const asked = ['running', 'preparing'].includes(task.state) ? pending.filter(approval => String(approval.taskId) === String(task.id) && (!approval.root || approval.root === project.root)) : [];
+      if (asked.length) {
+        for (const approval of asked) held.add(approval.id);
+        const [approval] = asked, text = wants(approval.summary) || 'use a tool';
+        // The age is how long the approval has waited, not how long the session has run.
+        rows.push({ ...base, agent: approval.role ?? 'lead', label: 'WANTS', approval, group: 0, order: time(approval.at), now: text, text, time: relativeTime(approval.at, now) });
+      } else if (['running', 'preparing'].includes(task.state)) {
+        const since = time(task.activeSince) || time(task.createdAt);
+        rows.push({ ...working(task), ...base, group: 1, order: since, now: latestStep(project, task.id) || firstLine(task.goal), time: clock(now - since) });
+      } else if (task.plan?.state === 'proposed') {
+        // A Task that waits for the owner's yes (lib/plan.mjs) needs them like a question does.
+        rows.push({ agent: 'lead', ...base, label: 'TASK', group: 0, order: last, now: `Task to approve: ${task.plan.title}`, time: relativeTime(new Date(last).toISOString(), now) });
+      } else if (task.state === 'needs_input') {
+        const response = task.reply?.outcome === 'needs_input' ? task.reply : task.result;
+        rows.push({ agent: 'lead', ...base, label: 'WAITING YOU', group: 0, order: last, now: firstLine(response?.question) || firstLine(task.goal), time: relativeTime(new Date(last).toISOString(), now) });
+      } else if (FINISHED.includes(task.state) && now - last < window) {
+        rows.push({ agent: '-', ...base, label: task.state, group: 3, order: -last, now: outcome(task), time: relativeTime(new Date(last).toISOString(), now) });
+      }
+    }
+    for (const request of project.queue ?? []) {
+      if (!['queued', 'starting', 'blocked', 'waiting'].includes(request.state)) continue;
+      if (request.origin) { matched.add(request.id); if (request.state === 'waiting') { rows.push(incoming(project, request, items.find(item => item.requestId === request.id), now)); continue; } if (peerQuestion(request.origin)) continue; }
+      const delay = time(request.notBefore) - now;
+      const label = request.state === 'queued' ? delay > 0 ? `retry ${Math.ceil(delay / 1000)}s` : 'queued' : request.state === 'waiting' ? 'saved' : request.state;
+      const text = request.state === 'blocked' ? `${firstLine(request.goal)} — ${firstLine(request.reason)}` : firstLine(request.goal);
+      // A blocked or saved request waits for the owner, like a question.
+      const owner = ['blocked', 'waiting'].includes(request.state);
+      rows.push({ kind: 'request', root: project.root, project: project.name, id: request.continuationTaskId ?? '', request, agent: request.origin ? peerName(request.origin.name, request.origin.peer) : '-', label, group: owner ? 0 : 2, order: owner ? time(request.createdAt) : (request.priority ?? 1) * 1e13 + time(request.queuedAt ?? request.createdAt), now: text, time: relativeTime(request.queuedAt ?? request.createdAt, now), cost: '-' });
+    }
+  }
+  for (const approval of pending) if (!held.has(approval.id)) rows.push(approvalRow(approval, projects, now));
+  for (const item of items) if (!(item.kind === 'incoming' && matched.has(item.requestId))) { const row = peerRow(item, online, now); if (row) rows.push(row); }
+  // Schedules come last: they wait for their time, not for the owner.
+  for (const schedule of schedules) {
+    const name = projects.find(project => project.root === schedule.root)?.name ?? schedule.project ?? '-';
+    const next = schedule.enabled ? time(schedule.nextRunAt) : 0;
+    rows.push({ kind: 'schedule', root: schedule.root, project: name, id: '', schedule, agent: 'lead', label: schedule.when.label, group: 4, order: schedule.enabled ? next : 9e15 + time(schedule.createdAt),
+      now: firstLine(schedule.goal), text: schedule.note ? `${firstLine(schedule.goal)} — ${firstLine(schedule.note)}` : firstLine(schedule.goal), time: schedule.enabled ? untilText(schedule.nextRunAt, now) : schedule.nextRunAt || schedule.when.kind !== 'once' ? 'paused' : 'done' });
+  }
+  const recent = rows.filter(row => row.group === 3).sort((a, b) => a.order - b.order).slice(0, 30);
+  // A live approval blocks its lead right now, so it leads Needs you.
+  return [...rows.filter(row => row.group !== 3), ...recent].sort((a, b) => a.group - b.group || Number(Boolean(b.approval)) - Number(Boolean(a.approval)) || a.order - b.order)
+    .map(row => ({ ...row, key: `${row.root}\0${row.kind}\0${row.kind === 'task' ? row.id : row.kind === 'peer' ? row.item.id : row.kind === 'schedule' ? row.schedule.id : row.kind === 'approval' ? row.approval.id : row.request.id}` }));
+}
+const fit = (value, width) => { const text = String(value ?? ''); return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}…` : text.padEnd(width); };
+const SPINNER = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
+// An incoming row reads "@name question", "@name review" or "@name task".
+const PEER_VERB = { ask: ['?', 'question'], review: ['◇', 'review'], handoff: ['⇄', 'task'] };
+// What a row shows first: an icon and tone for its state, and who does what. A session is
+// known by its title; its number is never shown.
+export function rowBadge(row, now = Date.now()) {
+  // A row is short in the list: the session's model is not named, a bot or a reviewer is.
+  const who = row.agent === 'lead' ? '' : `${row.agent} `;
+  if (row.approval) return { icon: '?', tone: 'orange', title: `${who}wants to` };
+  if (row.kind === 'task') {
+    const state = row.task.state;
+    if (row.archived) return { icon: '▫', tone: 'muted', title: 'archived' };
+    if (row.group === 1) return { icon: SPINNER[Math.floor(now / 100) % SPINNER.length], tone: 'blue', title: `${who}${row.label}` };
+    if (row.group === 0 && row.task.plan?.state === 'proposed') return { icon: '?', tone: 'orange', title: 'Task to approve' };
+    if (state === 'needs_input') return { icon: '?', tone: 'orange', title: 'asks you' };
+    if (state === 'ready') return { icon: '✓', tone: 'green', title: 'ready to publish' };
+    if (state === 'answered') return { icon: '✓', tone: 'green', title: 'answered' };
+    if (state === 'unverified') return { icon: '!', tone: 'orange', title: 'not verified' };
+    if (state === 'blocked') return { icon: '✗', tone: 'red', title: 'blocked' };
+    return { icon: '■', tone: 'muted', title: state };
+  }
+  if (row.kind === 'schedule') return { icon: '◷', tone: row.schedule.enabled ? 'blue' : 'muted', title: row.label };
+  if (row.kind === 'request') {
+    if (row.group === 0 && row.request.origin && row.request.state === 'waiting') { const [icon, verb] = PEER_VERB[row.request.origin.kind] ?? PEER_VERB.ask; return { icon, tone: 'orange', title: `${row.agent} ${verb}` }; }
+    const state = row.request.state, peer = row.agent !== '-' ? ` · ${row.agent}` : '';
+    if (state === 'blocked') return { icon: '✗', tone: 'red', title: `blocked${peer}` };
+    if (state === 'waiting') return { icon: '!', tone: 'orange', title: `saved${peer}` };
+    if (state === 'starting') return { icon: '›', tone: 'blue', title: `starting${peer}` };
+    return { icon: '·', tone: 'muted', title: `${row.label}${peer}` };
+  }
+  const kind = row.item.kind;
+  if (kind === 'incoming') { const [icon, verb] = PEER_VERB[row.item.request ?? row.item.origin?.kind] ?? PEER_VERB.ask; return { icon, tone: 'orange', title: `${row.agent} ${verb}` }; }
+  if (kind === 'held') return { icon: '↩', tone: 'orange', title: `reply to ${row.agent}` };
+  if (kind === 'draft') return { icon: '✎', tone: 'orange', title: `ask ${row.agent}?` };
+  if (kind === 'asked') return { icon: '→', tone: 'blue', title: `asked ${row.agent}` };
+  if (kind === 'answer') return { icon: '←', tone: 'green', title: `${row.agent} answered` };
+  return { icon: '·', tone: 'muted', title: `ask ${kind} · ${row.agent}` };
+}
+// The Sessions bar, beside the open session. A session reads "Trim coupon codes"; any
+// other row reads as its badge and its text.
+// A session at rest with a bot on a schedule shows when that bot runs next, in place of its age.
+const nextTimed = row => row.group === 3 ? (row.timed ?? []).filter(value => value.on && value.nextRunAt).map(value => value.nextRunAt).sort()[0] ?? null : null;
+const ageText = (row, now = Date.now()) => nextTimed(row) ? untilText(nextTimed(row), now) : String(row.time ?? '').replace('just now', 'now').replace(/ ago$/, '');
+// Cut at a word, as fitWords does. The bar is narrow, so a word that ends exactly at the edge
+// stays, and a cut never ends on the dot between two parts.
+const fitBar = (value, width) => {
+  const text = String(value ?? '').replace(/\s/g, ' ').trimEnd();
+  return (width > 1 && text.length > width && text[width - 1] === ' ' ? `${text.slice(0, width - 1).trimEnd()}…` : fitWords(text, width)).replace(/ ·…$/, '…');
+};
+// room: how wide the title may be, when the row is drawn.
+export function rowTitle(row, now = Date.now(), room = Infinity) {
+  if (row.kind === 'task' && !row.approval) return taskTitle(row.task);
+  // A request of yours is the message you wrote; one that waits to retry says so first.
+  if (row.kind === 'request' && !peerIncoming(row)) return `${row.label.startsWith('retry') ? `${row.label} · ` : ''}${firstLine(row.request.goal)}`;
+  const title = rowBadge(row, now).title, text = row.kind === 'schedule' ? row.now : row.text ?? row.now;
+  // A session that waits on an approval keeps its name, then what is wanted. When the row
+  // is too narrow for the name and the start of the approval, the name is cut first, at a
+  // word; a name that would be left with one word keeps the row instead.
+  if (row.kind === 'task') {
+    const want = row.agent === 'lead' ? text : `${title} ${text}`, name = taskTitle(row.task), short = Number.isFinite(room) && name.length + 3 + Math.min(want.length, 9) > room ? fitBar(name, Math.max(8, room - 12)) : name;
+    return `${short.includes(' ') ? short : name} · ${want}`;
+  }
+  return row.approval ? `${title} ${text}` : [title, text].filter(Boolean).join(' · ');
+}
+// The bar's project column, when its rows come from more than one project: as wide as the
+// longest name as it will show, cut at a word to about a quarter of the row. The ages then
+// share a width too, so the names line up.
+export function barColumns(rows, width) {
+  const roots = new Set(rows.map(row => row.root).filter(Boolean)), names = rows.map(row => row.project).filter(name => name && name !== '-'), most = Math.max(7, Math.floor(width * 0.28));
+  if (roots.size < 2 || !names.length) return { project: 0, clock: 0 };
+  return { project: Math.max(...names.map(name => fitBar(name, most).length)), clock: Math.min(6, Math.max(...rows.map(row => ageText(row).length))) };
+}
+// One row as coloured cells that add up to exactly `width` characters: the state's icon,
+// the title cut at a word, the project when asked for, and the age at the right edge.
+// A row too narrow for both keeps the title and leaves the project out.
+export function barCells(row, width, now = Date.now(), { project = 0, clock = 0 } = {}) {
+  const badge = rowBadge(row, now), quiet = row.group === 3 || badge.tone === 'muted', age = fit(ageText(row, now), Math.min(ageText(row, now).length, 6)).padStart(clock);
+  const named = project && width - 2 - (project + 1) - (age.length + 1) >= 12 ? project : 0, room = Math.max(1, width - 2 - (named ? named + 1 : 0) - (age.length + 1));
+  return [
+    { text: `${badge.icon} `, tone: badge.tone, bold: true },
+    { text: fitBar(rowTitle(row, now, room), room).padEnd(room), tone: quiet ? 'muted' : 'text', bold: row.group === 0 },
+    ...(named ? [{ text: ` ${fitBar(row.project === '-' ? '' : row.project, named).padEnd(named)}`, tone: 'muted' }] : []),
+    { text: ` ${age}`, tone: nextTimed(row) ? 'blue' : 'muted' },
+  ];
+}
+// What a row that is not a session shows beside the list: its badge and project, its whole
+// text, and the keys that act on it.
+export function rowCard(row, now = Date.now()) {
+  const badge = rowBadge(row, now), keys = rowActions(row).map(([key, label]) => `${key} ${label}`).join(' · ');
+  const text = row.kind === 'schedule' ? [row.text, row.schedule.enabled ? `Next run ${row.time}.` : row.time === 'paused' ? 'Paused.' : 'It has run.'].join('\n') : row.kind === 'approval' ? `${row.agent === 'lead' ? 'The model' : row.agent} wants to ${row.text}` : row.now;
+  return { title: [`${badge.icon} ${badge.title}`, row.project === '-' ? '' : row.project].filter(Boolean).join(' · '), tone: badge.tone === 'muted' ? 'text' : badge.tone, text, keys };
+}
+export const BOARD_GROUPS = [['Needs you', 'orange'], ['Running', 'blue'], ['Queued', 'text'], ['Recent', 'green'], ['Scheduled', 'blue'], ['Archived', 'muted']];
+// Board lines: a heading per non-empty group, a blank line between groups, then the rows.
+export function boardSections(rows) {
+  const lines = [];
+  BOARD_GROUPS.forEach(([name, tone], group) => {
+    const part = rows.filter(row => row.group === group);
+    if (!part.length) return;
+    if (lines.length) lines.push({ spacer: true });
+    lines.push({ header: name, tone, count: part.length });
+    for (const row of part) lines.push({ row });
+  });
+  return lines;
+}
+// The keys that act on a row, most useful first; the key bar shows the first three.
+export function rowActions(row) {
+  if (!row) return [];
+  if (row.approval) return [['y', 'allow'], ['n', 'deny'], ['enter', 'open']];
+  if (peerDecision(row)) return row.kind === 'peer' && ['held', 'draft'].includes(row.item.kind) ? [['y', 'send'], ['n', 'discard'], ['enter', 'read']] : [['y', 'accept'], ['n', 'decline'], ['enter', row.kind === 'peer' ? 'read' : 'open']];
+  if (row.kind === 'peer') return [['enter', 'read'], ['n', row.item.kind === 'asked' ? 'cancel' : 'dismiss']];
+  if (row.kind === 'schedule') return [['r', 'run now'], ['p', row.schedule.enabled ? 'pause' : 'resume'], ['x', 'delete'], ['enter', 'last run']];
+  if (row.kind === 'request') return ['blocked', 'waiting'].includes(row.request.state) ? [['enter', 'open'], ['r', 'retry'], ['s', 'cancel']] : [['enter', 'open'], ['s', 'cancel']];
+  if (row.archived) return [['enter', 'open'], ['u', 'unarchive'], ['e', 'rename']];
+  if (row.group === 1) return [['enter', 'open'], ['s', 'stop'], ['d', 'changes'], ['e', 'rename']];
+  if (row.group === 0 && row.task.plan?.state === 'proposed') return [['y', 'approve'], ['n', 'reject'], ['enter', 'open'], ['e', 'rename'], ['c', 'archive']];
+  const state = row.task.state;
+  if (state === 'needs_input') return [['enter', 'open'], ['a', 'answer'], ['d', 'changes'], ['e', 'rename'], ['c', 'archive']];
+  if (state === 'ready') return [['enter', 'open'], ['p', 'publish'], ['d', 'changes'], ['e', 'rename'], ['c', 'archive']];
+  if (state === 'answered') return [['enter', 'open'], ['a', 'follow up'], ['e', 'rename'], ['c', 'archive']];
+  return [['enter', 'open'], ['r', 'retry'], ['d', 'changes'], ['e', 'rename'], ['c', 'archive']];
+}