aegiscode 6.0.0 → 6.1.1

package/src/markdown.js

@@ -0,0 +1,303 @@
+'use strict';
+
+// Minimal markdown → styled span lines, in the spirit of Claude Code's
+// transcript rendering (monokai-flavored code, bold text, inline code).
+//
+// Ported from aegiscodex-dev/src/markdown.js (ESM → CommonJS). The one
+// structural change: instead of importing `span`/`w` from screen.js — which a
+// concurrent workstream is rewriting — this module carries a local cell-width
+// function and a local `span()` that produce the *same* shape the rest of the
+// design system consumes: { t: text, s: style-prefix, w: cell-width }. That
+// shape is a contract with whoever renders these lines.
+//
+// Colours come from the theme tokens (via themeOf(ctx)) rather than a bare
+// palette, so light/dark both work.
+
+const {
+  BOLD,
+  BOLD_OFF,
+  DIM,
+  ITALIC,
+  ITALIC_OFF,
+  RESET_BG,
+  RESET_FG,
+  themeOf,
+} = require('./theme.js');
+
+// Real terminal cell width, mirroring aegiscodex-dev/src/screen.js's w():
+// combining marks / variation selectors are zero-width, CJK fullwidth forms and
+// emoji are two cells, everything else one. A plain codepoint count misaligns
+// every width decision the moment a line contains CJK or emoji.
+const RE_ZERO = /[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F]/u;
+const RE_WIDE = /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uA960-\uA97F\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{1F1E6}-\u{1F1FF}\u{1F300}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F900}-\u{1F9FF}\u{1FA70}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
+function w(t) {
+  let n = 0;
+  for (const ch of String(t == null ? '' : t)) {
+    if (RE_ZERO.test(ch)) continue;
+    n += RE_WIDE.test(ch) ? 2 : 1;
+  }
+  return n;
+}
+
+/** A styled text run. Shape { t, s, w } is shared with the render model. */
+function span(style, t) {
+  return { t, s: style, w: w(t) };
+}
+
+// Turn an fg colour token into its background twin (38;2;R;G;B → 48;2;R;G;B),
+// so a code block sits on the theme's own code-block tint without typing a
+// colour inline — it stays theme-aware for free.
+function asBg(fgSgr) {
+  return fgSgr.replace('[38;2;', '[48;2;');
+}
+
+// Rendering rules verified against a live capture of Claude Code 2.1.211:
+//   - code lines: two-space indent, no fence label; a theme-tinted background
+//     so the block reads as a distinct surface
+//   - "- item" → "  - item" (hyphen kept, two-space indent)
+//   - "> quote" → "  ▎ quote" (dim ▎, italic text)
+function renderMarkdown(text, width, ctx) {
+  const t = themeOf(ctx);
+  const codeStyle = asBg(t.black) + t.white; // code-block surface
+  const lines = String(text == null ? '' : text).split('\n');
+  const out = [];
+  let inCode = false;
+  for (const raw of lines) {
+    const line = raw.replace(/\r$/, '');
+    if (line.startsWith('```')) {
+      inCode = !inCode;
+      continue; // fences are not rendered
+    }
+    if (inCode) {
+      out.push([span(codeStyle, '  ' + (line || ''))]);
+      continue;
+    }
+    out.push(...inlineLine(line, width, t));
+  }
+  return out;
+}
+
+// Render one plain line with inline **bold** / `code` / "- " bullets / quotes.
+function inlineLine(text, width, t) {
+  const ts = text.trimStart();
+  let body = text;
+  let prefix = null;
+  let isQuote = false;
+  // "- item" → "  - item": keep the hyphen marker with a two-space indent.
+  if (ts.startsWith('- ')) {
+    prefix = span(t.white, '  - ');
+    body = ts.slice(2);
+  } else if (ts.startsWith('  - ')) {
+    prefix = span(t.white, '    - ');
+    body = ts.slice(4);
+  } else if (ts.startsWith('> ')) {
+    // "> quote" → "  ▎ quote" (dim bar, italic body).
+    prefix = span(DIM, '  ▎ ');
+    body = ts.slice(2);
+    isQuote = true;
+  }
+
+  const spans = [];
+  const re = /(\*\*[^*]+\*\*|`[^`]+`)/g;
+  let last = 0;
+  let m;
+  while ((m = re.exec(body))) {
+    if (m.index > last) pushText(spans, body.slice(last, m.index), t);
+    const tok = m[0];
+    if (tok.startsWith('**')) pushText(spans, tok.slice(2, -2), t, BOLD);
+    else pushText(spans, tok.slice(1, -1), t, t.green);
+    last = m.index + tok.length;
+  }
+  if (last < body.length) pushText(spans, body.slice(last), t);
+  if (isQuote) {
+    // italicize the body of a quote line
+    for (const sp of spans) sp.s = ITALIC + sp.s + ITALIC_OFF;
+  }
+  return wrapInline(spans, width, prefix);
+}
+
+function pushText(spans, text, t, style) {
+  // Emit only non-space words; wrapInline adds separators. This avoids
+  // double-spacing when text arrives in chunks.
+  const s = style == null ? t.white : style;
+  const parts = text.split(/[ \t]+/).filter(Boolean);
+  for (const p of parts) {
+    spans.push(span(s, p));
+  }
+}
+
+// Wrap the word spans, prepending `prefix` verbatim to the first line only
+// (so "  - " / "  ▎ " markers keep their exact spacing).
+function wrapInline(line, width, prefix) {
+  const res = [];
+  let cur = prefix ? [prefix] : [];
+  let curW = prefix ? prefix.w : 0;
+  // Does the accumulator's last character end in whitespace? This mirrors the
+  // old /\s$/.test(cur.map(join)) check but tracks incrementally — the join
+  // version was O(line) PER WORD, making a paragraph render O(n²) and freezing
+  // the UI on long streaming answers.
+  let endsSpace = prefix ? /\s$/.test(prefix.t) : false;
+  const flush = () => {
+    if (cur.length) {
+      res.push(cur);
+      cur = [];
+      curW = 0;
+      endsSpace = false;
+    }
+  };
+  for (const sp of line) {
+    const words = sp.t.split(' ');
+    for (let i = 0; i < words.length; i++) {
+      const word = words[i];
+      const ww = w(word);
+      // Only insert a separator between words when nothing before already
+      // ends in whitespace (prevents "· " + word becoming "·  word").
+      const needSep = curW > 0 && i === 0 && /^\S/.test(word) && !endsSpace;
+      if (curW + ww + (needSep ? 1 : 0) > width && curW > 0) {
+        flush();
+      }
+      if (ww > width) {
+        // An unbreakable token wider than the terminal: emit one width-sized
+        // row per piece. Slice once into code-point arrays (O(n)) rather than
+        // re-slicing the remainder each piece (O(n²)), and cap the rows so a
+        // pathological token can't balloon the transcript either.
+        const chars = [...word];
+        const cws = chars.map((c) => w(c)); // cell width per code point, once
+        let total = 0;
+        for (const cw of cws) total += cw;
+        const MAX_PIECES = 400;
+        let j = 0;
+        let piece = 0;
+        while (total > width) {
+          // Take whole code points until the row is full — a codepoint slice
+          // (width chars) would split 2-cell CJK/emoji mid-glyph.
+          let take = 0;
+          let hw = 0;
+          while (j + take < chars.length && hw + cws[j + take] <= width) {
+            hw += cws[j + take];
+            take++;
+          }
+          if (!take) take = 1; // single glyph wider than the terminal
+          const head = chars.slice(j, j + take).join('');
+          if (curW) {
+            cur.push(span('', ' '));
+            curW++;
+            endsSpace = true;
+          }
+          cur.push(span(sp.s, head));
+          curW += hw;
+          flush();
+          j += take;
+          total -= hw;
+          if (++piece >= MAX_PIECES) {
+            if (curW) {
+              cur.push(span('', ' '));
+              curW++;
+            }
+            cur.push(span(sp.s, '…'));
+            flush();
+            return res.length ? res : [[span('', '')]];
+          }
+        }
+        const rest = chars.slice(j).join('');
+        if (rest) {
+          cur.push(span(sp.s, rest));
+          curW += w(rest);
+          endsSpace = /\s$/.test(rest);
+        }
+      } else {
+        if (curW > 0 && needSep) {
+          cur.push(span('', ' '));
+          curW++;
+          endsSpace = true;
+        }
+        cur.push(span(sp.s, word));
+        curW += ww;
+        endsSpace = /\s$/.test(word);
+      }
+    }
+  }
+  flush();
+  return res.length ? res : [[span('', '')]];
+}
+
+// The Monokai Extended diff preview shown on the theme picker (verbatim from
+// the reference capture; the literals are that theme's colours, not this one's).
+function renderDiffPreview(width, ctx) {
+  const t = themeOf(ctx);
+  const div = '╌'.repeat(Math.max(10, width - 4));
+  const num = (s) => span(t.gray + '\x1b[2m', s);
+  const plain = (s) => span(t.white, s);
+  const kw = (s) => span(RGB_LEGACY(102, 217, 239), s); // monokai: function
+  const fn = (s) => span(RGB_LEGACY(166, 226, 46), s);
+  const str = (s) => span(RGB_LEGACY(230, 219, 116), s);
+  const del = (s) => span('\x1b[38;2;220;90;90m\x1b[48;2;61;1;0m', s);
+  const delHi = (s) => span('\x1b[38;2;248;248;242m\x1b[48;2;92;2;0m', s);
+  const add = (s) => span('\x1b[38;2;80;200;80m\x1b[48;2;2;40;0m', s);
+  const addHi = (s) => span('\x1b[38;2;255;255;255m\x1b[48;2;4;71;0m', s);
+
+  const W = Math.max(28, width - 8);
+  const padBg = (spans, bg) => {
+    let cur = 0;
+    const out = [...spans];
+    for (const sp of out) cur += sp.w;
+    if (cur < W) out.push(span(bg + ' ', ' '.repeat(W - cur)));
+    out.push(span(RESET_BG, ''));
+    return out;
+  };
+
+  const lines = [];
+  lines.push([span(t.dim, div)]);
+  lines.push([num(' 1 '), kw('function'), plain(' '), fn('greet'), plain('()'), span(t.white, '{')]);
+  lines.push(
+    padBg(
+      [
+        num(' 2 '),
+        del('-'),
+        plain('  '),
+        del('console'),
+        span('\x1b[38;2;166;226;46m\x1b[48;2;61;1;0m', '.log'),
+        del('('),
+        str('"Hello, '),
+        delHi('World'),
+        del('!");'),
+      ],
+      '\x1b[48;2;61;1;0m'
+    )
+  );
+  lines.push(
+    padBg(
+      [
+        num(' 2 '),
+        add('+'),
+        plain('  '),
+        add('console'),
+        span('\x1b[38;2;166;226;46m\x1b[48;2;2;40;0m', '.log'),
+        add('('),
+        str('"Hello, '),
+        addHi('Claude'),
+        add('!");'),
+      ],
+      '\x1b[48;2;2;40;0m'
+    )
+  );
+  lines.push([num(' 3 '), plain('}')]);
+  lines.push([span(t.dim, div)]);
+  return lines;
+}
+
+function RGB_LEGACY(r, g, b) {
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+module.exports = {
+  renderMarkdown,
+  renderDiffPreview,
+  // Re-exported style tokens the reference exposed for legacy consumers.
+  RESET_FG,
+  BOLD,
+  BOLD_OFF,
+  // Also expose the local model helpers so consumers/tests can reuse them.
+  span,
+  w,
+};

package/src/overlays.js

@@ -0,0 +1,286 @@
+'use strict';
+
+/**
+ * Overlay renderers — the "/" command palette, the alt+p model picker, the
+ * /effort picker and the /resume session list. Ported from
+ * `aegiscodex-dev/src/commands.js` (which mirrors live captures of Claude Code
+ * 2.1.228: a gray `─` rule, a lavender `❯` cursor, a blue selected row, a
+ * `⎿  Usage: /x hint` hook under the focused command and a `·`-separated footer).
+ *
+ * Every renderer here is PURE. It receives the data it draws — a command list, a
+ * model list, an item list, a selection index, a width and a height — and
+ * returns an array of span lines (`{ t, s, w }`, see screen.js). It imports no
+ * registry, no session state and no key handling; the session loop owns those.
+ * The palette's command list is the array the concurrent workstream owns:
+ * `{ name, aliases?, help|desc, args?, category?, hint?, tool?|local?|unavailable? }`.
+ *
+ * Filtering reuses `./fuzzy.js` (fuzzyRankWithAliases + fuzzyMatchPositions).
+ * The require is guarded: if that module is absent the palette falls back to a
+ * substring filter so this file still loads and `node --check` still passes.
+ */
+
+const { span, padLine } = require('./screen.js');
+const { C, BOLD, BOLD_OFF, GLYPH } = require('./theme.js');
+
+// ── fuzzy.js (guarded require — a concurrent workstream owns it) ─────────────
+let fuzzy = null;
+try {
+  // eslint-disable-next-line global-require
+  fuzzy = require('./fuzzy.js');
+} catch {
+  fuzzy = null;
+}
+
+/** Rank palette commands by query (aliases count, like the reference). */
+function rankCommands(query, commands) {
+  if (fuzzy && typeof fuzzy.fuzzyRankWithAliases === 'function') {
+    return fuzzy.fuzzyRankWithAliases(query, commands, (c) => c.name, (c) => c.aliases || []);
+  }
+  // Fallback: plain case-insensitive substring across name + aliases.
+  const q = String(query || '').toLowerCase();
+  if (!q) return commands;
+  return commands.filter((c) =>
+    `${c.name} ${(c.aliases || []).join(' ')}`.toLowerCase().includes(q)
+  );
+}
+
+/** The short description a registry entry carries (help or desc). */
+const descOf = (c) => c.help != null ? c.help : (c.desc != null ? c.desc : '');
+/** The usage hint shown on the selected row's `⎿` hook (hint, else args). */
+const hintOf = (c) => (c.hint != null ? c.hint : (c.args != null ? c.args : ''));
+
+/** Pad (and, if needed, truncate) every line to `width` cells so an overlay can
+ *  never paint wider than the terminal. */
+function fit(lines, width) {
+  return lines.map((l) => padLine(l, width));
+}
+
+/** A full-width blank row. */
+const blank = (width) => [span('', ' '.repeat(Math.max(0, width)))];
+
+// Phase 10b (2.1.228 port): split a command name into spans that bold the
+// characters which matched the query; the selected row reads blue.
+function boldMatched(query, name, colour) {
+  const pos = fuzzy && typeof fuzzy.fuzzyMatchPositions === 'function'
+    ? fuzzy.fuzzyMatchPositions(query, name)
+    : [];
+  if (!pos || !pos.length) return [span(colour, name)];
+  const segs = [];
+  let last = 0;
+  for (const p of pos) {
+    if (p > last) segs.push(span(colour, name.slice(last, p)));
+    segs.push(span(colour + BOLD, name[p]));
+    last = p + 1;
+  }
+  if (last < name.length) segs.push(span(colour, name.slice(last)));
+  return segs;
+}
+
+// ── Palette overlay (/) ──────────────────────────────────────────────────────
+
+/**
+ * @param {Array|{commands:Array, query?:string, sel?:number}} commands
+ *        the registry command list (or a state object carrying it as `.commands`)
+ * @param {{query?:string, sel?:number}} [state]
+ * @param {number} [width]
+ * @param {number} [height]
+ */
+function renderPalette(commands, state = {}, width = 80, height = 24) {
+  // Accept either `renderPalette(list, {query, sel}, w, h)` or the reference's
+  // `renderPalette({commands, query, sel}, w, h)`.
+  if (!Array.isArray(commands) && commands && typeof commands === 'object') {
+    state = commands;
+    commands = Array.isArray(commands.commands) ? commands.commands : [];
+  }
+  const list = rankCommands(state.query || '', commands || []);
+  const sel = Number.isInteger(state.sel) ? state.sel : 0;
+  const total = list.length;
+  const per = Math.max(1, Math.min(12, height - 8));
+  const start = Math.max(0, Math.min(sel - Math.floor(per / 2), Math.max(0, total - per)));
+  const visible = list.slice(start, start + per);
+
+  const lines = [];
+  lines.push(blank(width));
+  lines.push([span(C.gray, '  ' + '─'.repeat(Math.max(10, width - 4)))]);
+  for (let i = 0; i < visible.length; i++) {
+    const c = visible[i];
+    const idx = start + i;
+    const active = idx === sel;
+    const left = active ? span(C.lavender, GLYPH.cursor) : span('', ' ');
+    const row = active ? C.blue : C.white;
+    const name = [span(row, '/'), ...boldMatched(state.query || '', c.name, row)];
+    const pad = ' '.repeat(Math.max(1, 22 - [...c.name].length));
+    lines.push([
+      span('', ' '),
+      left,
+      span('', ' '),
+      ...name,
+      span(c.unavailable ? C.dim : C.gray, pad + descOf(c)),
+    ]);
+    if (active && hintOf(c)) {
+      lines.push([span('', ' '), span(C.gray, `${GLYPH.hook}  Usage: /${c.name} ${hintOf(c)}`)]);
+    }
+  }
+  while (lines.length < 4 + per * 2) lines.push(blank(width));
+  lines.push([span(C.gray, '  ' + '─'.repeat(Math.max(10, width - 4)))]);
+  lines.push([
+    span(
+      C.gray,
+      `  type to filter ${GLYPH.bullet} enter to run ${GLYPH.bullet} esc to close`
+    ),
+  ]);
+  return fit(lines, width);
+}
+
+// ── Model picker overlay (alt+p) ─────────────────────────────────────────────
+
+/**
+ * @param {Array} models entries ({id, label?, name?, note?, model?})
+ * @param {number} sel selected index
+ * @param {number} width
+ * @param {number} height
+ * @param {string|null} current the currently-pinned model id
+ */
+function renderModelPicker(models, sel = 0, width = 80, height = 24, current = null) {
+  const lines = [];
+  lines.push(blank(width));
+  lines.push([span('', ' '), span(C.white + BOLD, 'Select model'), span(BOLD_OFF, '')]);
+  lines.push([span('', ' '), span(C.gray, 'Switch between models. Your pick becomes the default for new sessions.')]);
+  lines.push([span('', ' '), span(C.gray, 'Manage the list with /model add|remove — /model <id> switches directly.')]);
+  lines.push(blank(width));
+  for (let i = 0; i < models.length; i++) {
+    const m = models[i] || {};
+    const label = m.label || m.name || m.id || '';
+    const active = i === sel;
+    const cur = current != null && m.id === current;
+    const left = active ? span(C.lavender, GLYPH.cursor) : span('', ' ');
+    const num = span(C.gray, `${i + 1}.`);
+    const nameSpan = active ? span(C.lavender, label) : span(C.white, label);
+    const mark = cur ? span(C.green, ' ' + GLYPH.check) : span('', '');
+    const pad = ' '.repeat(Math.max(1, 22 - [...label].length));
+    lines.push([
+      span('', ' '),
+      left,
+      span('', ' '),
+      num,
+      span('', ' '),
+      nameSpan,
+      mark,
+      span(C.gray, pad + (m.note || m.model || '')),
+    ]);
+  }
+  lines.push(blank(width));
+  lines.push([span('', ' '), span(C.gray, `arrow keys to navigate ${GLYPH.bullet} enter to select ${GLYPH.bullet} esc to cancel`)]);
+  return fit(lines, width);
+}
+
+// ── Effort picker overlay (/effort) ──────────────────────────────────────────
+
+const EFFORT_LEVELS = [
+  { label: 'Low', note: 'Fastest, most efficient' },
+  { label: 'Medium', note: 'Balanced' },
+  { label: 'High', note: 'Highest quality, slowest' },
+];
+
+/**
+ * @param {number} sel selected index
+ * @param {number} width
+ * @param {string|null} current the currently-selected effort level
+ * @param {Array} [levels] override the level table
+ */
+function renderEffortPicker(sel = 0, width = 80, current = null, levels = EFFORT_LEVELS) {
+  const lines = [];
+  lines.push(blank(width));
+  lines.push([span('', ' '), span(C.white + BOLD, 'Select effort'), span(BOLD_OFF, '')]);
+  lines.push([span('', ' '), span(C.gray, 'Controls how much reasoning the model puts into each turn.')]);
+  lines.push(blank(width));
+  for (let i = 0; i < levels.length; i++) {
+    const lv = levels[i];
+    const active = i === sel;
+    const cur = current != null && String(current).toLowerCase() === String(lv.label).toLowerCase();
+    const left = active ? span(C.lavender, GLYPH.cursor) : span('', ' ');
+    const nameSpan = active ? span(C.lavender, lv.label) : span(C.white, lv.label);
+    const mark = cur ? span(C.green, ' ' + GLYPH.check) : span('', '');
+    const pad = ' '.repeat(Math.max(1, 12 - [...lv.label].length));
+    lines.push([span('', ' '), left, span('', ' '), nameSpan, mark, span(C.gray, pad + lv.note)]);
+  }
+  lines.push(blank(width));
+  lines.push([span('', ' '), span(C.gray, `arrow keys to navigate ${GLYPH.bullet} enter to select ${GLYPH.bullet} esc to cancel`)]);
+  return fit(lines, width);
+}
+
+// ── Resume-list overlay (/resume) ────────────────────────────────────────────
+
+/**
+ * @param {Array} items entries ({own?, summary?, cwd?, time?})
+ * @param {number} sel selected index
+ * @param {number} width
+ * @param {number} height
+ */
+function renderResumeList(items, sel = 0, width = 80, height = 24) {
+  const list = Array.isArray(items) ? items : [];
+  const lines = [];
+  lines.push(blank(width));
+  lines.push([span('', ' '), span(C.gray, '─'.repeat(Math.max(10, width - 4)))]);
+  lines.push([
+    span('', ' '),
+    span(C.white + BOLD, 'Resume session'),
+    span(C.gray, ` (${sel + 1} of ${Math.max(1, list.length)})`),
+    span(BOLD_OFF, ''),
+  ]);
+  // search box
+  const boxW = Math.max(10, width - 4);
+  lines.push([span('', ' '), span(C.gray, '╭' + '─'.repeat(Math.max(0, boxW - 2)) + '╮')]);
+  lines.push([
+    span('', ' '),
+    span(C.gray, '│'),
+    span(C.white, '⌕ Search…'),
+    span('', ' '.repeat(Math.max(0, boxW - 9))),
+    span(C.gray, '│'),
+  ]);
+  lines.push([span('', ' '), span(C.gray, '╰' + '─'.repeat(Math.max(0, boxW - 2)) + '╯')]);
+  lines.push(blank(width));
+  const per = Math.max(2, Math.min(6, height - 16));
+  const start = Math.max(0, Math.min(sel - Math.floor(per / 2), Math.max(0, list.length - per)));
+  const visible = list.slice(start, start + per);
+  for (let i = 0; i < visible.length; i++) {
+    const it = visible[i] || {};
+    const idx = start + i;
+    const active = idx === sel;
+    const left = active ? span(C.lavender, GLYPH.cursor) : span('', ' ');
+    const tag = it.own ? span(C.green, GLYPH.star + ' ') : span(C.gray, GLYPH.bullet + ' ');
+    const title = active
+      ? span(C.white + BOLD, it.summary || '(untitled)')
+      : span(C.white, it.summary || '(untitled)');
+    lines.push([span('', ' '), left, span('', ' '), tag, title]);
+    lines.push([span('', '     '), span(C.gray, `${it.cwd || '~'} ${GLYPH.bullet} ${ago(it.time)}`)]);
+  }
+  while (lines.length < 6 + per * 2) lines.push(blank(width));
+  lines.push([span('', ' '), span(C.gray, '─'.repeat(Math.max(10, width - 4)))]);
+  lines.push([
+    span('', ' '),
+    span(
+      C.gray,
+      `Ctrl+A all projects ${GLYPH.bullet} Space to preview ${GLYPH.bullet} Type to search ${GLYPH.bullet} Esc to cancel`
+    ),
+  ]);
+  return fit(lines, width);
+}
+
+function ago(ts) {
+  if (!ts) return '';
+  const ms = Date.now() - new Date(String(ts)).getTime();
+  if (!(ms >= 0) || Number.isNaN(ms)) return '';
+  if (ms < 60_000) return `${Math.max(1, Math.round(ms / 1000))}s ago`;
+  if (ms < 3_600_000) return `${Math.round(ms / 60_000)}m ago`;
+  if (ms < 86_400_000) return `${Math.round(ms / 3_600_000)}h ago`;
+  return `${Math.round(ms / 86_400_000)}d ago`;
+}
+
+module.exports = {
+  boldMatched,
+  renderPalette,
+  renderModelPicker,
+  renderEffortPicker,
+  renderResumeList,
+};