atris 3.58.7 → 3.59.0

package/lib/receipt-block.js

@@ -98,18 +98,116 @@ function directProofText(value) {
   return ran ? `${ran[1]} passed` : text;
 }
 
-function proofText(receipt) {
+// A receipt is a text from a good employee: one sentence a friend would send,
+// plus one link a stranger can check. Ids, statuses, scores and verifier
+// output stay underneath (they feed the rating); they never lead the surface.
+// Standard: atris-labs atris/wiki/systems/receipt-standard.md
+
+function sentence(value) {
+  const text = trimPunctuation(value);
+  if (!text) return '';
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+}
+
+// Bracketed IPv6 hosts need their own alternative: the plain class stops at
+// ] and would cut http://[::1]:3000 down to http://[::1 .
+const URL_RE = /https?:\/\/\[[0-9a-f.:]+\][^\s)>\]]*|https?:\/\/[^\s)>\]]+/i;
+const URL_RE_GLOBAL = new RegExp(URL_RE.source, 'gi');
+
+// A stranger cannot open localhost, loopback or *.local addresses, so they
+// never count as the check link no matter which field they came from.
+// Parsing with URL normalizes tricks like 127.1 or 0x7f.1 into 127.0.0.1.
+function localCheckUrl(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith('[') && host.endsWith(']')) host = host.slice(1, -1);
+  return host === 'localhost'
+    || host === '0.0.0.0'
+    || host === '::1'
+    || host.startsWith('127.')
+    || host.endsWith('.local');
+}
+
+// A checked/tested note that is nothing but a local URL carries no check a
+// stranger can run; the verifier line speaks instead.
+function localOnlyUrl(text) {
+  const value = trimPunctuation(text);
+  return /^https?:\/\/\S+$/i.test(value) && localCheckUrl(value);
+}
+
+function firstUrl(...values) {
+  for (const value of values) {
+    if (!value) continue;
+    for (const raw of String(value).match(URL_RE_GLOBAL) || []) {
+      const url = raw.replace(/[.,;:]+$/, '');
+      if (!localCheckUrl(url)) return url;
+    }
+  }
+  return '';
+}
+
+// The link a stranger can click. Read explicit link fields first, then any
+// URL the landing text already mentions. Local-only hosts never count, and
+// empty means the receipt has none.
+function checkLink(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  return firstUrl(
+    land.link, land.url, land.check_url, land.proof_url,
+    res.link, res.url, res.pr_url, res.share_url, res.tick?.pr_url, res.tick?.share_url,
+    land.checked, land.tested,
+  );
+}
+
+// What a reader can check: the link when there is one, else the plain
+// check that passed. Never "verifier passed" or "receipt is present".
+function checkText(receipt) {
+  const link = checkLink(receipt);
+  if (link) return link;
   const land = landing(receipt);
   const verifier = verifierResult(receipt);
-  if (land.checked) return directProofText(land.checked);
-  if (land.tested) return directProofText(land.tested);
+  if (land.checked && !localOnlyUrl(land.checked)) return directProofText(land.checked);
+  if (land.tested && !localOnlyUrl(land.tested)) return directProofText(land.tested);
   if (verifier) {
-    const command = lowerLine(verifier.command || receipt?.verifier || 'configured verifier');
+    const command = lowerLine(verifier.command || receipt?.verifier || 'the checks');
     return `${command} ${verifier.passed ? 'passed' : 'failed'}`;
   }
-  if (result(receipt).passed === true) return 'receipt says verifier passed';
-  if (receipt?.at) return `receipt saved at ${lowerLine(receipt.at)}`;
-  return 'receipt is present';
+  if (result(receipt).passed === true) return 'the checks passed';
+  return '';
+}
+
+// Dollars a mission actually brought in. Read from the landing (or result)
+// so a member can write it next to what happened; the backend sums the same
+// field into the member rating. Only a real number or a plain decimal string
+// may count: Number() alone would read true as 1, [5] as 5, "0x10" as 16 and
+// "1e3" as 1000. Junk and negatives count as zero.
+const PLAIN_DECIMAL_RE = /^\d+(\.\d+)?$/;
+
+function plainDecimalAmount(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : 0;
+  if (typeof value !== 'string') return 0;
+  const text = value.trim();
+  return PLAIN_DECIMAL_RE.test(text) ? Number(text) : 0;
+}
+
+function earnedUsd(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  for (const value of [land.earned_usd, res.earned_usd, res.tick?.earned_usd]) {
+    if (value === undefined || value === null || value === '') continue;
+    const amount = plainDecimalAmount(value);
+    return amount > 0 ? Math.round(amount * 100) / 100 : 0;
+  }
+  return 0;
+}
+
+function usdText(amount) {
+  const whole = Number.isInteger(amount);
+  return `$${amount.toLocaleString('en-US', { minimumFractionDigits: whole ? 0 : 2, maximumFractionDigits: 2 })}`;
 }
 
 function nextText(receipt) {
@@ -117,43 +215,53 @@ function nextText(receipt) {
   return lowerLine(text);
 }
 
+function whatText(receipt, max = 180) {
+  return historicalLandingText(trimPunctuation(changedText(receipt)), max);
+}
+
+// One line: "What happened. Check it: <link or check>."
+function checkLine(receipt, max = 160) {
+  const check = trimPunctuation(checkText(receipt));
+  if (!check) return '';
+  // A link stays bare so it copies clean; a plain check reads as a sentence.
+  return firstUrl(check) ? `Check it: ${check}` : `Check it: ${truncateLine(check, max)}.`;
+}
+
 function renderEmailLine(receipt) {
-  const what = historicalLandingText(trimPunctuation(changedText(receipt)), 180);
-  const scale = scaleText(receipt);
-  const proof = historicalLandingText(trimPunctuation(proofText(receipt)), 90);
-  return `${what}; ${scale}; we know because ${proof}.`;
+  const what = sentence(whatText(receipt));
+  const check = checkLine(receipt);
+  return check ? `${what} ${check}` : what;
 }
 
 function renderMorningCardRow(receipt) {
-  return `- mission: ${renderEmailLine(receipt).replace(/\.$/, '')}`;
+  return `- ${renderEmailLine(receipt).replace(/\.$/, '')}`;
 }
 
+// Three lines lead. The machinery (size, status, mission id) sits below as
+// details, where a builder can find it and a customer never has to read it.
 function renderPageSection(receipt) {
   const next = nextText(receipt);
-  const lines = [
-    '## mission receipt',
-    '',
-    `- what: ${truncateLine(trimPunctuation(changedText(receipt)), 160)}`,
-    `- how big: ${scaleText(receipt)}`,
-    `- how we know: ${truncateLine(trimPunctuation(proofText(receipt)), 160)}`,
-    `- status: ${statusText(receipt)}`,
-  ];
-  if (receipt?.mission_id) lines.push(`- mission: ${lowerLine(receipt.mission_id)}`);
-  if (next) lines.push(`- next: ${truncateLine(trimPunctuation(next), 160)}`);
+  const check = checkLine(receipt);
+  const lines = ['## mission receipt', '', sentence(whatText(receipt, 160))];
+  if (check) lines.push(check);
+  if (next) lines.push(`Next: ${sentence(truncateLine(next, 160))}`);
+  const details = [scaleText(receipt), `status ${statusText(receipt)}`];
+  const earned = earnedUsd(receipt);
+  if (earned > 0) details.push(`earned ${usdText(earned)}`);
+  if (receipt?.mission_id) details.push(`mission ${lowerLine(receipt.mission_id)}`);
+  lines.push('', `details: ${details.join('; ')}`);
   return lines.join('\n');
 }
 
 function renderCard(receipt) {
-  const status = statusText(receipt);
-  const what = truncateLine(trimPunctuation(changedText(receipt)), 64);
-  const scale = scaleText(receipt);
-  const proof = truncateLine(trimPunctuation(proofText(receipt)), 88);
+  const what = sentence(whatText(receipt, 64));
+  const check = trimPunctuation(checkText(receipt));
   return {
     kind: 'statement',
     headline: what,
     text: what,
-    kicker: `${status} mission receipt`,
-    sub: `${scale}; ${proof}`,
+    kicker: 'mission receipt',
+    sub: check ? `Check it: ${truncateLine(check, 88)}` : '',
     brand: 'atris',
     size: 'og',
     theme: 'atris',
@@ -161,6 +269,7 @@ function renderCard(receipt) {
 }
 
 module.exports = {
+  earnedUsd,
   renderCard,
   renderPageSection,
   renderEmailLine,

package/lib/roster-markdown.js

@@ -0,0 +1,206 @@
+'use strict';
+
+// ROSTER.md as text: which lines are job lines, worker lines, and team
+// lines, and edits that touch one job while keeping everything else the
+// person wrote (comments, order, blank lines, notes). What a line means
+// (which engine, which job) lives in engine-registry; this file only knows
+// the shape.
+//
+// Two shapes read side by side. The sectioned shape, which assign writes:
+//   ## build
+//   - claude code, model: opus 5.5
+//   - codex, effort: medium
+// and the older one-line shape, still read as before:
+//   build: claude opus 5.5, backup codex
+
+const OLD_ROSTER_NOTE = '> edit any time. each line is job: engine and model, an optional effort (low, medium, high, xhigh, max), then optional "backup <engine and model>", "max 20 min", and "until 2026-10-24" (the year is required).';
+const ROSTER_NOTE = '> edit any time. each "## job" lists its workers in order, one per line: "- tool, model: name", then optional "effort: medium", "max: 20 min", and "until 2026-10-24" (the year is required). the first ready worker leads and the rest back it up.';
+
+const ROSTER_MARKDOWN_TEMPLATE = [
+  '# roster',
+  '',
+  ROSTER_NOTE,
+  '',
+];
+
+function stripInlineComments(text) {
+  return String(text || '').replace(/<!--.*?-->/g, '').trim();
+}
+
+// Sections: anything under a top heading, "## jobs", or "## roster" holds
+// one-line job lines; "## team" holds member lines; any other heading is a
+// job whose "- " lines are its workers. Other lines under a job heading are
+// free notes that are never read as picks.
+function sectionForHeading(level, title) {
+  const name = String(title || '').trim().toLowerCase();
+  if (level === 1) return 'jobs';
+  if (name === 'team') return 'team';
+  if (name === 'jobs' || name === 'roster') return 'jobs';
+  return 'job';
+}
+
+function scanRosterMarkdown(text) {
+  const source = String(text || '');
+  const newline = source.includes('\r\n') ? '\r\n' : '\n';
+  const lines = source.split(/\r?\n/);
+  const entries = [];
+  const headings = [];
+  let section = 'jobs';
+  let heading = null;
+  let inComment = false;
+  lines.forEach((raw, index) => {
+    const line = raw.trim();
+    if (inComment) {
+      if (line.includes('-->')) inComment = false;
+      return;
+    }
+    if (!line) return;
+    if (line.startsWith('<!--')) {
+      if (!line.includes('-->')) inComment = true;
+      return;
+    }
+    if (line.startsWith('>') || line.startsWith('```')) return;
+    const headingMatch = /^(#{1,6})\s*(.*)$/.exec(line);
+    if (headingMatch) {
+      section = sectionForHeading(headingMatch[1].length, headingMatch[2]);
+      heading = { index, lineNumber: index + 1, level: headingMatch[1].length, title: stripInlineComments(headingMatch[2]), raw: line, section };
+      headings.push(heading);
+      return;
+    }
+    const dashed = /^-\s+/.test(line);
+    if (line.startsWith('-') && !dashed) return;
+    const body = stripInlineComments(dashed ? line.replace(/^-\s+/, '') : line);
+    if (!body) return;
+    if (section === 'job') {
+      // Only "- " lines under a job heading are workers.
+      if (!dashed) return;
+      entries.push({ index, lineNumber: index + 1, section, raw: line, name: '', value: body, heading: heading.title, headingIndex: heading.index, dashed, malformed: false });
+      return;
+    }
+    // A "- " bullet under the jobs heading is a note; under team it is a
+    // member line.
+    if (dashed && section !== 'team') return;
+    const colon = body.indexOf(':');
+    if (dashed && colon <= 0) return;
+    entries.push({
+      index,
+      lineNumber: index + 1,
+      section,
+      raw: line,
+      name: colon > 0 ? body.slice(0, colon).trim() : '',
+      value: colon > 0 ? body.slice(colon + 1).trim() : '',
+      dashed,
+      malformed: colon <= 0,
+    });
+  });
+  return { lines, entries, headings, newline };
+}
+
+function joinLines(lines, newline) {
+  const text = lines.join(newline);
+  return text.endsWith(newline) ? text : `${text}${newline}`;
+}
+
+function trimTrailingBlank(lines) {
+  const out = [...lines];
+  while (out.length && !out[out.length - 1].trim()) out.pop();
+  return out;
+}
+
+function isBlank(line) {
+  return !String(line || '').trim();
+}
+
+// One job's section: its heading, the index where it ends (the next heading
+// or the end of the file), and its worker lines in order.
+function jobSections(scan) {
+  return scan.headings
+    .map((heading, i) => ({ heading, next: scan.headings[i + 1] }))
+    .filter(({ heading }) => heading.section === 'job')
+    .map(({ heading, next }) => ({
+      heading,
+      end: next ? next.index : scan.lines.length,
+      workers: scan.entries.filter((entry) => entry.section === 'job' && entry.headingIndex === heading.index),
+    }));
+}
+
+// Two headings say the same thing when they differ only in case or spacing.
+function sameHeading(a, b) {
+  const plain = (text) => stripInlineComments(String(text || '').replace(/^#+\s*/, '')).replace(/\s+/g, ' ').toLowerCase();
+  return plain(a) === plain(b);
+}
+
+// Replace one job's worker lines with lines (in order), add the section when
+// it is missing, or remove every section for the job when lines is null. matches(title)
+// names the section by its heading; heading is the text for a new one, and
+// when given it also replaces an existing heading that says something else
+// (a note at the end of the old heading stays). Every other line outside that
+// job's workers stays as written.
+function replaceJobSection(text, { matches, heading, lines: workerLines }) {
+  const base = String(text || '').trim() ? String(text) : ROSTER_MARKDOWN_TEMPLATE.join('\n');
+  const scan = scanRosterMarkdown(base);
+  const lines = [...scan.lines];
+  const sections = jobSections(scan).filter((entry) => matches(entry.heading.title));
+  const section = sections[0];
+  if (section && workerLines === null) {
+    // Every section for the job goes, last first so earlier indexes hold; a
+    // second section that was ignored must not become the job.
+    for (const entry of [...sections].reverse()) {
+      let start = entry.heading.index;
+      let end = Math.min(entry.end, lines.length);
+      // Take the blank lines after the section with it, so no double gap stays.
+      while (end > start && isBlank(lines[end - 1])) end -= 1;
+      while (end < lines.length && isBlank(lines[end])) end += 1;
+      if (end >= lines.length) while (start > 0 && isBlank(lines[start - 1])) start -= 1;
+      lines.splice(start, end - start);
+    }
+    return joinLines(trimTrailingBlank(lines), scan.newline);
+  }
+  if (section) {
+    const at = section.workers.length ? section.workers[0].index : section.heading.index + 1;
+    for (const worker of [...section.workers].reverse()) lines.splice(worker.index, 1);
+    lines.splice(at, 0, ...workerLines);
+    if (heading && !sameHeading(section.heading.raw, heading)) {
+      const note = /\s*(<!--.*?-->)\s*$/.exec(section.heading.raw);
+      lines[section.heading.index] = note ? `${heading} ${note[1]}` : heading;
+    }
+    return joinLines(trimTrailingBlank(lines), scan.newline);
+  }
+  if (workerLines === null) return joinLines(trimTrailingBlank(lines), scan.newline);
+  // A new job goes right before the team, else at the end.
+  const team = scan.headings.find((entry) => entry.section === 'team');
+  const block = [heading, ...workerLines];
+  if (team) {
+    let at = team.index;
+    while (at > 0 && isBlank(lines[at - 1])) at -= 1;
+    lines.splice(at, 0, ...(at > 0 ? [''] : []), ...block);
+    return joinLines(trimTrailingBlank(lines), scan.newline);
+  }
+  const trimmed = trimTrailingBlank(lines);
+  return joinLines([...trimmed, ...(trimmed.length ? [''] : []), ...block], scan.newline);
+}
+
+// Replace every line for which rewrite(entry) returns a string, leaving the
+// rest of the file byte for byte.
+function rewriteRosterValues(text, rewrite) {
+  const scan = scanRosterMarkdown(text);
+  const lines = [...scan.lines];
+  for (const entry of scan.entries) {
+    const next = rewrite(entry);
+    if (typeof next !== 'string') continue;
+    const indent = /^\s*/.exec(lines[entry.index])[0];
+    lines[entry.index] = `${indent}${next}`;
+  }
+  return joinLines(trimTrailingBlank(lines), scan.newline);
+}
+
+module.exports = {
+  OLD_ROSTER_NOTE,
+  ROSTER_NOTE,
+  ROSTER_MARKDOWN_TEMPLATE,
+  scanRosterMarkdown,
+  jobSections,
+  replaceJobSection,
+  rewriteRosterValues,
+  joinLines,
+};

package/lib/roster-models.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// What model and effort each roster line really runs, and where each came
+// from, so the roster view never shows an engine with a blank model. A pin
+// on the line wins; with no pin, codex reads the top of its own settings
+// file, claude-family engines run the atris default, and every other engine
+// rides its own default. Nothing here spawns an engine or goes online.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  DEFAULT_CLAUDE_RUNNER_MODEL,
+} = require('./runner-command');
+
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+const ATRIS_PINNED = Object.freeze(['atris-fast', 'composer']);
+
+// ~/.codex/config.toml unless a path is given. Test runs never read the real
+// file unless they point at one on purpose.
+function codexConfigFile(options = {}) {
+  if (options.codexConfigPath) return options.codexConfigPath;
+  if (process.env.ATRIS_CODEX_CONFIG_PATH) return process.env.ATRIS_CODEX_CONFIG_PATH;
+  if (process.env.NODE_TEST_CONTEXT) return '';
+  return path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'config.toml');
+}
+
+// The top-level model and model_reasoning_effort, the lines before the first
+// [section]. A tiny line reader, not a toml parser: anything else is ignored.
+function readCodexSettings(options = {}) {
+  const file = codexConfigFile(options);
+  if (!file) return {};
+  let text = '';
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return {};
+  }
+  const settings = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith('[')) break;
+    const match = /^(model|model_reasoning_effort)\s*=\s*(?:"([^"]*)"|'([^']*)')\s*(?:#.*)?$/.exec(line);
+    if (match) settings[match[1]] = (match[2] !== undefined ? match[2] : match[3]).trim();
+  }
+  return settings;
+}
+
+// claude-opus-5-5 reads as "opus 5.5"; anything else as written.
+function modelLabel(model) {
+  const text = String(model || '').trim();
+  const grok = /^grok-(\d+(?:\.\d+)?)(-build-fast)?$/.exec(text);
+  if (grok) return `grok ${grok[1]}${grok[2] ? ' fast' : ''}`;
+  const match = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2}))?(?:-\d{8})?$/.exec(text);
+  if (!match) return text;
+  return `${match[1]} ${match[2]}${match[3] ? `.${match[3]}` : ''}`;
+}
+
+const SOURCE_TAIL = Object.freeze({ 'codex settings': 'from codex settings', 'atris default': 'atris default' });
+const SOURCE_INLINE = Object.freeze({ 'codex settings': 'from codex settings', 'atris default': 'by atris default' });
+
+// One engine's real model and effort. Sources: roster (pinned on the line),
+// codex settings, atris default, or own default (the engine decides).
+function engineRunsView(engineId, { model = '', effort = '' } = {}, options = {}) {
+  const id = RUNNER_PROFILE_ALIASES[engineId] || engineId;
+  const def = RUNNER_PROFILE_DEFS[id] || {};
+  const view = { engine: id, model: '', model_source: 'own default', effort: '', effort_source: '' };
+  if (model) {
+    view.model = model;
+    view.model_source = 'roster';
+  } else if (id === 'codex') {
+    const settings = readCodexSettings(options);
+    if (settings.model) {
+      view.model = settings.model;
+      view.model_source = 'codex settings';
+    }
+  } else if (CLAUDE_FAMILY.includes(id)) {
+    view.model = String(process.env.ATRIS_RUNNER_MODEL || '').trim() || def.model || DEFAULT_CLAUDE_RUNNER_MODEL;
+    view.model_source = 'atris default';
+  } else if (ATRIS_PINNED.includes(id) && def.model) {
+    view.model = def.model;
+    view.model_source = 'atris default';
+  }
+  if (effort) {
+    view.effort = effort;
+    view.effort_source = 'roster';
+  } else if (id === 'codex') {
+    const settings = readCodexSettings(options);
+    if (settings.model_reasoning_effort) {
+      view.effort = settings.model_reasoning_effort;
+      view.effort_source = 'codex settings';
+    }
+  }
+  view.text = `${id} (${runsDetail(view)})`;
+  return view;
+}
+
+function runsDetail(view) {
+  const items = [{ text: view.model ? modelLabel(view.model) : 'its own default', source: view.model ? view.model_source : 'roster' }];
+  if (view.effort) items.push({ text: view.effort, source: view.effort_source });
+  const sourced = [...new Set(items.map((item) => item.source).filter((source) => SOURCE_TAIL[source]))];
+  // Every item shares one source: say it once at the end.
+  if (sourced.length === 1 && items.every((item) => item.source === sourced[0])) {
+    return [...items.map((item) => item.text), SOURCE_TAIL[sourced[0]]].join(', ');
+  }
+  return items.map((item) => (SOURCE_INLINE[item.source] ? `${item.text} ${SOURCE_INLINE[item.source]}` : item.text)).join(', ');
+}
+
+// --- what this machine offers --------------------------------------------
+//
+// Cheap local sources only: never the network, never the tool itself. Codex
+// keeps a cache of the models it can run; claude takes the names atris knows;
+// every other engine lists its seed models.
+
+const KNOWN_CLAUDE_MODELS = Object.freeze(['opus 5.5', 'opus 5', 'sonnet 5', 'haiku 4.5', 'fable 5.1']);
+
+// ~/.codex/models_cache.json unless a path is given. Test runs never read the
+// real file unless they point at one on purpose.
+function codexModelsCacheFile(options = {}) {
+  if (options.codexModelsCachePath) return options.codexModelsCachePath;
+  if (process.env.ATRIS_CODEX_MODELS_CACHE_PATH) return process.env.ATRIS_CODEX_MODELS_CACHE_PATH;
+  if (process.env.NODE_TEST_CONTEXT) return '';
+  return path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'models_cache.json');
+}
+
+// Every "slug" in the cache, in order, once each. [] when there is no cache
+// or it does not parse.
+function readCodexModelSlugs(options = {}) {
+  const file = codexModelsCacheFile(options);
+  if (!file) return [];
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return [];
+  }
+  const slugs = [];
+  const walk = (value, depth) => {
+    if (depth > 6 || !value || typeof value !== 'object') return;
+    if (Array.isArray(value)) {
+      value.forEach((item) => walk(item, depth + 1));
+      return;
+    }
+    if (typeof value.slug === 'string' && value.slug.trim() && !slugs.includes(value.slug.trim())) slugs.push(value.slug.trim());
+    for (const child of Object.values(value)) if (child && typeof child === 'object') walk(child, depth + 1);
+  };
+  walk(data, 0);
+  return slugs;
+}
+
+function homeLabel(file) {
+  const home = os.homedir();
+  const rel = path.relative(home, file);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? `~/${rel}` : file;
+}
+
+// One row per installed engine: the models it offers and where that list
+// came from ("from <file>" or "known names").
+function availableModels(engines, options = {}) {
+  return (engines || []).map((engine) => {
+    const id = engine.id;
+    if (id === 'codex') {
+      const slugs = readCodexModelSlugs(options);
+      if (slugs.length) return { engine: id, models: slugs, source: `from ${homeLabel(codexModelsCacheFile(options))}` };
+    }
+    if (id === 'claude') return { engine: id, models: [...KNOWN_CLAUDE_MODELS], source: 'known names' };
+    const models = Array.isArray(engine.models) ? engine.models.filter(Boolean) : [];
+    return { engine: id, models, source: 'known names' };
+  });
+}
+
+module.exports = {
+  modelLabel,
+  readCodexSettings,
+  engineRunsView,
+  availableModels,
+};