cawdev-cli 0.9.0 → 1.0.0-beta

package/runner/attach.mjs

@@ -45,8 +45,17 @@
 // Zero dependencies, so this is ANSI escapes and `setRawMode` rather than a
 // curses library.
 
+import { spawn } from 'node:child_process';
 import { connect } from 'node:net';
+import { basename, dirname } from 'node:path';
 import { listSockets, socketPathFor } from './control.mjs';
+import {
+  addProject, addWorkspace, agentsOf, pathsOf, readConfigFile, reloadIfRunning,
+  setAcceptsRulesFromConsole, setAgentEnabled, slugsOf,
+} from './configure.mjs';
+import {
+  TYPE_A_PATH, absolute, completePath, describe, inspectPath, listDirectories,
+} from './paths.mjs';
 import { clip, keyList, padVisible, painter, stripAnsi, visibleWidth, wrap } from '../lib/ansi.mjs';
 import { oneLine } from './brand.mjs';
 import { Scrollback } from './scrollback.mjs';
@@ -531,6 +540,10 @@ export function footerLines(state, width, ink = painter(3)) {
   // both: a key list under a half-typed prompt is a list of keys that would
   // land in the prompt.
   if (input) {
+    if (input.preview) {
+      // R289: what the path on the line IS, above the line being typed.
+      lines.push(padVisible(clip(`   ${ink.muted(input.preview)}`, width), width));
+    }
     lines.push(padVisible(clip(` ${ink.accent(input.label)} ${input.text}`, width), width));
   } else if (keys.length || status) {
     lines.push(padVisible(clip(` ${keyList(keys, status, width - 1, ink)}`, width), width));
@@ -645,12 +658,67 @@ async function runSignIn(session, ink = painter()) {
   return outcome;
 }
 
+/** What Esc throws out of a config step — R288. Compared by identity, never caught by message. */
+export const CANCELLED = Symbol('cancelled');
+
+/**
+ * A configure.mjs prompt, split into what is PRINTED and what the footer keeps
+ * — R289. `confirm` asks "…long sentence… [Y/n] ", and a footer line that
+ * clips at the width would cut the sentence and keep the brackets. So anything
+ * longer than a label is said in the transcript and the label is the trailing
+ * `[default]` with the caret, or just the caret. A short prompt stays whole.
+ */
+export function splitPrompt(prompt, limit = 40) {
+  const text = String(prompt ?? '').trim();
+  const tail = /\s*(\[[^\]]*\])$/.exec(text);
+  const bracket = tail ? tail[1] : '';
+  const question = tail ? text.slice(0, tail.index).trim() : text;
+  if (text.length <= limit) {
+    return { said: '', label: `${text} ▸` };
+  }
+  return { said: question, label: `${bracket ? `${bracket} ` : ''}▸` };
+}
+
+/** The agents the config screen offers a switch for, whether or not they are on. */
+const KNOWN_AGENTS = ['claude', 'agy'];
+
+/**
+ * The config screen's rows, with the state of each thing on the row — R288.
+ *
+ * Pure, so the wording can be read in a test: "Disable claude" when claude is
+ * on and "Enable claude" when it is not, because a row that always said
+ * "enable" would ask the person to remember what the file says. The hint is
+ * where the current value lives; the label is the change.
+ */
+export function configMenu(file, runner = {}) {
+  const slugs = slugsOf(file);
+  const agents = agentsOf(file);
+  const rulesOn = file.acceptsRulesFromConsole === true;
+  const checkouts = slugs.map((slug) => `${slug}: ${pathsOf(file.projects[slug]).length}`).join(', ');
+  return new Select({
+    kind: 'config',
+    title: `this machine — ${runner.name ?? file.name ?? 'cawdev'}`,
+    rows: [
+      { id: 'add-project', label: 'Add a project', hint: slugs.length ? `serves ${slugs.join(', ')}` : 'serves nothing yet' },
+      { id: 'add-workspace', label: 'Add a workspace to a project', hint: checkouts || 'no projects to add one to' },
+      ...[...new Set([...KNOWN_AGENTS, ...agents])].map((command) => (agents.includes(command)
+        ? { id: `agent:${command}`, label: `Disable ${command}`, hint: 'spawned here now' }
+        : { id: `agent:${command}`, label: `Enable ${command}`, hint: 'not spawned here' })),
+      rulesOn
+        ? { id: 'rules', label: 'Stop accepting permission rules from the console', hint: 'on now' }
+        : { id: 'rules', label: 'Accept permission rules from the console', hint: 'off now' },
+      { id: 'show', label: "Show this machine's config", hint: runner.configPath ?? '' },
+    ],
+  });
+}
+
 /** The slash commands, and the one place they are described. */
 const COMMANDS = [
   ['/help', 'this list'],
   ['/login', 'sign in through the browser'],
   ['/logout', 'forget the stored session on this machine'],
   ['/runs', 'the run list — the same as L'],
+  ['/config', "this machine's config — the same as c"],
   ['/cancel', 'cancel the session you are watching'],
   ['/log', "the daemon's own log, on or off"],
   ['/quit', 'stop the runner and leave (--leave-running keeps it up)'],
@@ -749,6 +817,16 @@ export class Attached {
     this.settled = new Set();
     /** Ctrl+C, armed. See {@link onInterrupt}. */
     this.interrupting = false;
+    /**
+     * The config walk in progress, if one is — R288.
+     *
+     * `answer` resolves the question it is waiting on — the line editor or
+     * the picker hands its result here instead of to a session — and `cancel`
+     * rejects it with {@link CANCELLED}, which is what unwinds the whole step
+     * on Esc. One walk at a time, because two writing one file is R41 on a
+     * laptop.
+     */
+    this.configuring = null;
   }
 
   /**
@@ -1306,6 +1384,8 @@ export class Attached {
       case 'l':
       case 'L':
         return this.openList();
+      case 'c':
+        return void this.openConfig();
       case 'g':
         this.showLog = !this.showLog;
         return this.note(this.showLog ? "printing the daemon's log" : 'printing the session');
@@ -1386,6 +1466,8 @@ export class Attached {
     this.deciding = null;
     this.history.reset();
     this.dirty = true;
+    // A config question closed this way is cancelled, not left waiting — R288.
+    this.configuring?.cancel?.();
     return open;
   }
 
@@ -1440,6 +1522,11 @@ export class Attached {
 
   /** The commands still matching what is typed, and which one is highlighted. */
   matching() {
+    if (this.mode === 'typing' && this.input.path) {
+      // R289: the directories that would complete the path, drawn where the
+      // commands are drawn for a `/`.
+      return { rows: this.input.path.rows, at: this.input.path.at };
+    }
     if (this.mode !== 'typing' || this.input.kind !== 'command') {
       return { rows: [], at: 0 };
     }
@@ -1460,6 +1547,7 @@ export class Attached {
         return this.note('');
       }
       const back = this.input.back;
+      const kind = this.input.kind;
       this.input = null;
       this.history.reset();
       if (back) {
@@ -1469,6 +1557,13 @@ export class Attached {
       this.mode = 'keys';
       this.answering = null;
       this.deciding = null;
+      if (kind === 'config') {
+        // Esc from a config question cancels the STEP, not just the line —
+        // R288. The walk it was in is waiting on this answer and would
+        // otherwise wait for ever.
+        this.configuring?.cancel?.();
+        return this.note('');
+      }
       return this.note('cancelled');
     }
 
@@ -1483,6 +1578,10 @@ export class Attached {
     }
 
     if (key === '\t') {
+      if (this.input.path) {
+        this.completeThePath();
+        return undefined;
+      }
       if (rows.length) {
         // As far as they agree, which is what every shell does and nobody has
         // to be taught. One match completes it whole.
@@ -1494,6 +1593,11 @@ export class Attached {
     }
 
     if (key === `${ESC}[A` || key === `${ESC}OA` || key === '\x10') {
+      if (this.input.path && rows.length) {
+        this.input.path.at = (at - 1 + rows.length) % rows.length;
+        this.dirty = true;
+        return undefined;
+      }
       if (rows.length && this.input.showing !== false) {
         this.input.at = (at - 1 + rows.length) % rows.length;
         this.dirty = true;
@@ -1507,6 +1611,11 @@ export class Attached {
       return undefined;
     }
     if (key === `${ESC}[B` || key === `${ESC}OB` || key === '\x0e') {
+      if (this.input.path && rows.length) {
+        this.input.path.at = (at + 1) % rows.length;
+        this.dirty = true;
+        return undefined;
+      }
       if (rows.length && this.input.showing !== false) {
         this.input.at = (at + 1) % rows.length;
         this.dirty = true;
@@ -1547,6 +1656,9 @@ export class Attached {
       return undefined;
     }
     this.dirty = true;
+    if (this.input.path) {
+      void this.refreshPath();
+    }
     return undefined;
   }
 
@@ -1559,6 +1671,14 @@ export class Attached {
     this.mode = 'keys';
     this.history.reset();
 
+    if (kind === 'config') {
+      // Before the empty-line rule, on purpose: every config question shows a
+      // default in its label, and enter on an empty line TAKES it — R288.
+      // Not remembered either; a path typed once is not a prompt worth
+      // offering back next launch.
+      this.configuring?.answer?.(this.pastes.expand(typed));
+      return this.note('');
+    }
     if (!typed || typed === '/') {
       // Nothing typed is not an answer, and a question that was open is still
       // open — so an empty line goes back to it rather than dropping it.
@@ -1644,6 +1764,9 @@ export class Attached {
       // is being written when none is is one the next reader will believe.
       this.answering = null;
       this.deciding = null;
+      if (select.kind === 'config') {
+        this.configuring?.cancel?.();
+      }
       // Escape leaves without changing anything, which is the promise the key
       // makes everywhere else.
       return this.note('');
@@ -1685,6 +1808,11 @@ export class Attached {
       }
       return void this.allow(row.id);
     }
+    if (select.kind === 'config') {
+      // R288: the walk asked, the walk gets the row. Nothing is decided here.
+      this.configuring?.answer?.(row);
+      return undefined;
+    }
     return undefined;
   }
 
@@ -1696,6 +1824,14 @@ export class Attached {
    */
   onLine(text) {
     const typed = String(text).trim();
+    if (this.input?.kind === 'config' && !this.select) {
+      // The plain path's half of R288: a config question waiting on a line
+      // takes the whole line, empty included, and nothing else reads it.
+      this.input = null;
+      this.mode = 'keys';
+      this.configuring?.answer?.(typed);
+      return undefined;
+    }
     if (this.select) {
       const picked = pickFromLine(this.select, typed);
       if (picked) {
@@ -1903,6 +2039,307 @@ export class Attached {
     return false;
   }
 
+  // --- this machine's config — R288 ------------------------------------------
+
+  /**
+   * `c` — configure this machine from inside the terminal.
+   *
+   * R283 built `cawdev config …` as a shell subcommand, and the first person to
+   * launch the new CLI could not find it: they were HERE, attached, which is
+   * where cawdev lives on a machine, and nothing here said a word about
+   * configuration. So the same functions get a second door. The rows carry the
+   * state each toggle is in, because a list that says "enable claude" when
+   * claude is already on is a list asking somebody to guess.
+   *
+   * Every change goes through configure.mjs — one implementation, two doors —
+   * and its questions come back through this class's own line editor and its
+   * own picker: {@link askLine} and {@link askPick} are the adapters, and the
+   * walk between them cannot tell readline from raw mode. The daemon is never
+   * told anything over R52's socket; the file is written as the operator and,
+   * for the two settings runner.mjs re-reads, the process is sent a SIGHUP
+   * through the pid the hello already carries.
+   */
+  async openConfig() {
+    if (this.configuring) {
+      return this.note('already configuring — finish that, or esc');
+    }
+    if (!this.runner) {
+      return this.note('not connected to the daemon yet');
+    }
+    if (this.runner.configPath === undefined) {
+      // An older daemon: it does not say which file it booted from, and
+      // guessing at one is how a config screen edits the wrong machine.
+      return this.note('this daemon is older than this client — q, then cawdev again, and c will work');
+    }
+    if (this.runner.configPath === null) {
+      return this.note('this daemon was started from the environment, with no config file — nothing here to edit');
+    }
+    const file = await readConfigFile(this.runner.configPath);
+    if (!file) {
+      return this.note(`could not read ${this.runner.configPath}`);
+    }
+
+    this.configuring = { answer: null, cancel: null };
+    try {
+      await this.configWalk(file);
+    } catch (failure) {
+      if (failure === CANCELLED) {
+        this.note('nothing changed');
+      } else {
+        this.say(`  ${this.ink.danger(failure.message)}`);
+        this.note('nothing changed');
+      }
+    } finally {
+      this.configuring = null;
+      this.dirty = true;
+    }
+    return undefined;
+  }
+
+  /** One step of the screen: pick what to change, then change it. */
+  async configWalk(file) {
+    const ink = this.ink;
+    const say = (line) => this.say(line);
+    const configPath = this.runner.configPath;
+    const url = this.session.url;
+    const ask = { line: (prompt) => this.askLine(prompt) };
+    const pick = (_ask, _say, select) => this.askPick(select).then((row) => ({ done: 'chosen', row }));
+
+    const chosen = await this.askPick(configMenu(file, this.runner));
+    this.say('');
+    this.say(`${ink.bold(ink.accent(' config '))} ${ink.text(chosen.label)}`);
+
+    if (chosen.id === 'show') {
+      const shown = { ...file };
+      if (shown.token) shown.token = `${String(shown.token).slice(0, 10)}…`;
+      for (const line of JSON.stringify(shown, null, 2).split('\n')) {
+        this.say(`  ${ink.text(line)}`);
+      }
+      this.say(`  ${ink.muted(configPath)}`);
+      return this.note('');
+    }
+
+    if (chosen.id === 'add-project') {
+      // Widens the machine's token on the platform, which only a person may do.
+      // `requireSignIn` has already said so; a second note would bury it.
+      if (!this.requireSignIn('add a project to this machine')) {
+        return undefined;
+      }
+      await addProject({
+        configPath, file, url, session: this.session, ask, say, ink, pick,
+        askPath: (spec) => this.askPath(spec),
+        inspect: this.options.inspect ?? inspectPath,
+        clone: (gitUrl, path) => this.cloneInto(gitUrl, path),
+      });
+      return this.afterProjectsChanged();
+    }
+    if (chosen.id === 'add-workspace') {
+      await addWorkspace({
+        configPath, file, url, session: this.session, ask, say, ink, pick,
+        askPath: (spec) => this.askPath(spec),
+        inspect: this.options.inspect ?? inspectPath,
+        clone: (gitUrl, path) => this.cloneInto(gitUrl, path),
+      });
+      return this.afterProjectsChanged();
+    }
+    if (chosen.id.startsWith('agent:')) {
+      const command = chosen.id.slice('agent:'.length);
+      const next = await setAgentEnabled({
+        file, configPath, ask, say, ink, command, enabled: !agentsOf(file).includes(command),
+      });
+      this.runner.agents = agentsOf(next);
+      return this.reloadDaemon(next);
+    }
+    if (chosen.id === 'rules') {
+      const next = await setAcceptsRulesFromConsole({
+        file, configPath, ask, say, ink, enabled: file.acceptsRulesFromConsole !== true,
+      });
+      this.runner.acceptsConsoleRules = next.acceptsRulesFromConsole === true;
+      return this.reloadDaemon(next);
+    }
+    return this.note('');
+  }
+
+  /**
+   * The two settings the daemon re-reads on SIGHUP, applied to the one this
+   * terminal is attached to — R283's `reloadIfRunning` with the pid handed in,
+   * since the hello already says which process this is.
+   */
+  async reloadDaemon(next) {
+    await reloadIfRunning(next.name, (line) => this.say(line), this.ink, {
+      pidOf: async () => this.runner?.pid ?? null,
+      // Injectable so a test can watch the signal without sending one.
+      kill: this.options.kill ?? ((pid, signal) => process.kill(pid, signal)),
+    });
+    return this.note('');
+  }
+
+  /**
+   * Adding a project or a workspace is not hot-swappable — `config.projects`
+   * is read once at boot — so this says what happens next rather than letting
+   * the row above look like it took effect. The same sentence `cawdev --setup`
+   * says, because it is the same fact.
+   */
+  afterProjectsChanged() {
+    const ink = this.ink;
+    this.say(`  ${ink.muted('This daemon is still on the config it booted with.')}`);
+    this.say(`  ${ink.muted('Press')} ${ink.text('q')} ${ink.muted('to stop it, and the next')} `
+      + `${ink.text('cawdev')} ${ink.muted('starts one on what you just set up.')}`);
+    return this.note('saved — q, then cawdev, to serve it');
+  }
+
+  /**
+   * One line, asked through this class's own editor — the `ask.line` shape
+   * configure.mjs takes. Enter on an empty line resolves '' (the default the
+   * label shows); Esc rejects with {@link CANCELLED}, which unwinds the step.
+   */
+  askLine(prompt, { prefill = '', path = null } = {}) {
+    return new Promise((resolve, reject) => {
+      this.configuring.answer = (text) => {
+        this.configuring.answer = null;
+        this.configuring.cancel = null;
+        resolve(text);
+      };
+      this.configuring.cancel = () => {
+        this.configuring.answer = null;
+        this.configuring.cancel = null;
+        reject(CANCELLED);
+      };
+      const { said, label } = splitPrompt(prompt);
+      if (said) {
+        // R289: a question longer than a label is PRINTED, where it wraps and
+        // stays, and the footer keeps the short part — a line the footer clips
+        // is a question nobody read.
+        this.say(`  ${this.ink.text(said)}`);
+      }
+      if (this.plain && !said) {
+        // No footer to carry the label through a pipe, so it is printed.
+        this.say(`  ${label}`);
+      }
+      this.type('config', label, prefill);
+      if (path) {
+        this.input.path = { ...path, rows: [], at: 0, preview: '', completion: null };
+        void this.refreshPath();
+      }
+    });
+  }
+
+  /**
+   * Where a checkout goes — R289. Suggestions first, each saying what is there
+   * now; the last row opens a line PRE-FILLED with the first suggestion, with
+   * tab completing directories and a preview under it. `~` expands. The path
+   * comes back absolute; configure.mjs inspects it again before acting.
+   */
+  async askPath({ question, suggestions, slug, gitUrl, inspect = inspectPath }) {
+    this.say(`  ${this.ink.text(question)}`);
+    const rows = [];
+    for (const each of suggestions) {
+      const seen = await inspect(each.path, { gitUrl });
+      rows.push({ id: each.path, label: each.path, hint: `${each.why} · ${describe(seen, slug)}` });
+    }
+    rows.push({ id: TYPE_A_PATH, label: 'Type a path', hint: 'pre-filled · tab completes · ~ works' });
+    const chosen = await this.askPick(new Select({ title: question, rows }));
+    if (chosen.id !== TYPE_A_PATH) {
+      return chosen.id;
+    }
+    const typed = await this.askLine('path', {
+      prefill: suggestions[0]?.path ?? '',
+      path: { slug, gitUrl, inspect },
+    });
+    return absolute(typed || suggestions[0]?.path || '');
+  }
+
+  /**
+   * What the path on the line points at, recomputed as it is typed: the
+   * directories that would complete it (drawn above the line, tab takes them)
+   * and one line saying what is there (drawn under it). The inspection is
+   * debounced and checked against the line afterwards, so a slow disk never
+   * paints a verdict about a path that has since changed.
+   */
+  async refreshPath() {
+    const input = this.input;
+    if (!input?.path) return;
+    const text = input.line.text;
+    const expanded = absolute(text);
+    const completion = completePath(text, await listDirectories(
+      text.endsWith('/') ? expanded : dirname(expanded),
+    ));
+    if (this.input !== input || input.line.text !== text) return;
+    input.path.completion = completion;
+    input.path.rows = completion.matches
+      .filter((match) => `${match}/` !== expanded && match !== expanded)
+      .slice(0, 8)
+      .map((match) => [`${basename(match)}/`, '']);
+    input.path.at = Math.min(input.path.at, Math.max(0, input.path.rows.length - 1));
+    this.dirty = true;
+
+    await new Promise((done) => setTimeout(done, 120));
+    if (this.input !== input || input.line.text !== text) return;
+    const seen = await input.path.inspect(expanded, { gitUrl: input.path.gitUrl });
+    if (this.input !== input || input.line.text !== text) return;
+    input.path.preview = `${expanded} — ${describe(seen, input.path.slug)}`;
+    this.dirty = true;
+  }
+
+  /** Tab on a path: as far as the matches agree; cycle them when they do not. */
+  completeThePath() {
+    const input = this.input;
+    const path = input?.path;
+    if (!path?.completion) return;
+    const { completed, matches } = path.completion;
+    if (completed !== input.line.text) {
+      input.line.set(completed);
+    } else if (matches.length > 1) {
+      const pick = matches[path.at % matches.length];
+      input.line.set(`${pick}/`);
+      path.at = (path.at + 1) % matches.length;
+    }
+    this.dirty = true;
+    void this.refreshPath();
+  }
+
+  /** One row, through the one select widget — R83's rule, kept. */
+  askPick(select) {
+    return new Promise((resolve, reject) => {
+      this.configuring.answer = (row) => {
+        this.configuring.answer = null;
+        this.configuring.cancel = null;
+        resolve(row);
+      };
+      this.configuring.cancel = () => {
+        this.configuring.answer = null;
+        this.configuring.cancel = null;
+        reject(CANCELLED);
+      };
+      select.kind = 'config';
+      this.openPicker(select);
+    });
+  }
+
+  /**
+   * `git clone` with its progress printed into the transcript rather than onto
+   * a terminal in raw mode, and `GIT_TERMINAL_PROMPT=0` because a clone that
+   * stops to ask for a password here would hang the screen with no prompt on
+   * it: the credential helper may answer, a person cannot.
+   */
+  cloneInto(gitUrl, path) {
+    return new Promise((done, fail) => {
+      const child = spawn('git', ['clone', '--progress', gitUrl, path], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+      });
+      const print = (chunk) => {
+        for (const line of String(chunk).split(/\r?\n|\r/)) {
+          if (line.trim()) this.say(`  ${this.ink.muted(line)}`);
+        }
+      };
+      child.stdout.on('data', print);
+      child.stderr.on('data', print);
+      child.on('error', (failure) => fail(new Error(`Could not run git: ${failure.message}`)));
+      child.on('close', (code) => (code === 0 ? done() : fail(new Error(`git clone exited ${code}.`))));
+    });
+  }
+
   // --- slash commands ---------------------------------------------------------
 
   async runCommand(text) {
@@ -1916,7 +2353,7 @@ export class Attached {
         }
         this.say('');
         this.say(this.ink.bold(' keys'));
-        this.say(this.ink.muted('   enter prompt · / command · L runs · 1-9 pick a run'));
+        this.say(this.ink.muted('   enter prompt · / command · L runs · 1-9 pick a run · c config'));
         this.say(this.ink.muted('   a answer · y/s/Y/n permission · x cancel · g log · q quit'));
         this.say(this.ink.muted('   in a list: ↑↓ move · 1-9 pick · enter choose · esc leave'));
         this.say(this.ink.muted('   while typing: ↑↓ history · tab complete · esc back · ctrl+c twice quits'));
@@ -1935,6 +2372,8 @@ export class Attached {
         return this.note('signed out — /login to sign in again');
       case 'runs':
         return this.openList();
+      case 'config':
+        return void this.openConfig();
       case 'cancel':
         return void this.cancel();
       case 'log':
@@ -2294,6 +2733,7 @@ export class Attached {
         matches: this.input?.showing === false ? { rows: [], at: 0 } : this.matching(),
         input: this.mode === 'typing' ? {
           label: this.input.label,
+          preview: this.input.path?.preview ?? '',
           // The width the line has left, so the caret stays on screen when the
           // text is longer than the terminal — see Line.window.
           text: this.input.line.render(
@@ -2349,6 +2789,7 @@ export class Attached {
         + `${ink.muted('permission')}`);
     }
     parts.push(`${ink.text('x')} ${ink.muted('cancel')}`);
+    parts.push(`${ink.text('c')} ${ink.muted('config')}`);
     parts.push(`${ink.text('q')} ${ink.muted(this.stopsTheDaemon() ? 'stop' : 'quit')}`);
     return parts;
   }

package/runner/banner.mjs

@@ -19,6 +19,12 @@
 //                 profile: a question is bounded here and nowhere else
 //   the browser   R61, and the one line that says an agent may reach Chrome
 //
+// R283 adds two more, because both became things a machine can now be
+// RECONFIGURED into without a restart (`cawdev config`, and the daemon's own
+// SIGHUP handler in runner.mjs): which agent(s) this machine spawns, and —
+// when it could be read — the CLI's own version, so a stale one is visible at
+// the moment it would matter most, before anything has failed yet.
+//
 // It prints once, at boot. Anything that changes afterwards belongs in the
 // log, not here.
 
@@ -31,7 +37,7 @@ import { padVisible } from '../lib/ansi.mjs';
  * Lines rather than output, so the caller decides where it goes — and so this
  * can be tested by reading it rather than by capturing a stream.
  */
-export function bannerLines(config, ink) {
+export function bannerLines(config, ink, cliVersionValue = null) {
   const lines = ['', ...mark(ink, { tagline: 'the runner' }), ''];
 
   const label = (text) => ink.muted(padVisible(text, 12));
@@ -39,6 +45,10 @@ export function bannerLines(config, ink) {
 
   say('platform', ink.accent(config.url));
   say('runner', ink.text(config.name));
+  if (cliVersionValue) {
+    say('cli', ink.muted(cliVersionValue));
+  }
+  say('agents', ink.text((config.agentCommands ?? []).join(', ') || 'claude'));
 
   const projects = Object.entries(config.projects);
   projects.forEach(([slug, project], at) => {