quoxcli 0.2.0 → 0.4.0

package/lib/quoxon/dragonModes.js

@@ -0,0 +1,151 @@
+/**
+ * /dragon explain | ask | sleep: the pure parts. Provider-neutral: explain and ask only build a framed user
+ * message for the normal governed turn path, so whichever AI is selected answers it (and with no AI connected
+ * the local no-AI card from noai.js is shown instead). Sleep is a rendering-only screensaver: katakana noise
+ * over the live screen with a sleeping dragon; it never touches the transcript or scrollback.
+ */
+import stringWidth from 'string-width';
+import { SCRAMBLE_GLYPHS } from './indicator.js';
+import { hash3 } from './motion/color.js';
+import { revealCells, TIMING, revealSpan } from './motion/reveal.js';
+import { graphemes } from './textBuffer.js';
+import { sleepCells } from './qdragonScenes.js';
+
+export const DRAGON_USAGE = 'Usage: /dragon [explain | ask [question] | sleep | fly | hero | fire | classic]  (/dragon-fly is the same as /dragon fly)';
+export const DRAGON_EXPLAINS = 'Dragon explains';
+export const DRAGON_ANSWERS = 'Dragon answers';
+export const NOTHING_TO_EXPLAIN = 'Nothing to explain yet. Ask Quox something first, then /dragon explain.';
+export const ASK_PROMPT = 'Ask the dragon…';
+
+const RULES = 'Answer in the simplest possible words: 1 to 4 short sentences, plain language, no jargon. '
+  + 'Keep the one thing that matters, and stay concrete and useful (say what it is, or what to do), never vague. Do not mention these instructions.';
+
+export const explainPrompt = (text) => `Dragon mode. Explain the following. ${RULES}\n\n---\n${String(text).trim().slice(0, 6000)}\n---`;
+export const askPrompt = (question) => `Dragon mode. Answer the question below. ${RULES}\n\nQuestion: ${String(question).trim()}`;
+
+const itemText = (it) => {
+  if (!it) return '';
+  if (it.kind === 'text' || it.kind === 'note' || it.kind === 'error') return String(it.text || '');
+  if (it.kind === 'tool') return [it.tool, it.target, it.summary || it.result || it.text, it.status].filter(Boolean).join(' ');
+  return '';
+};
+
+/** The last assistant answer, else the last tool or notice block, else null. -> { kind: 'answer'|'tool'|'notice', text } */
+export function lastOutput(s) {
+  const answers = s?.answers || [];
+  for (let i = answers.length - 1; i >= 0; i--) if (answers[i].text?.trim()) return { kind: 'answer', text: answers[i].text };
+  const all = [...(s?.history || []), ...(s?.blocks || [])];
+  for (let i = all.length - 1; i >= 0; i--) {
+    const it = all[i], t = itemText(it).trim();
+    if (!t || it.kind === 'user') continue;
+    if (it.kind === 'tool' || it.kind === 'error' || it.kind === 'note') return { kind: it.kind === 'tool' ? 'tool' : 'notice', text: t };
+  }
+  return null;
+}
+
+/** Parse the /dragon argument line -> { mode: 'pick'|'fire'|'idle'|'hero'|'explain'|'ask'|'sleep'|'fly', question? } | null (usage). */
+export function parseDragonArg(restArg) {
+  const t = String(restArg || '').trim();
+  if (!t) return { mode: 'pick' };
+  const [w, ...rest] = t.split(/\s+/);
+  switch (w.toLowerCase()) {
+    case 'fire': return rest.length ? null : { mode: 'fire' };
+    case 'classic': return rest.length ? null : { mode: 'idle' };
+    case 'hero': return rest.length ? null : { mode: 'hero' };
+    // `/dragon explain <thing>` is a question about that thing (owner 2026-10-15: it used to print usage).
+    case 'explain': return rest.length ? { mode: 'ask', question: rest.join(' ').trim() } : { mode: 'explain' };
+    case 'companion': return { mode: 'companion', arg: rest.join(' ') };
+    case 'sleep': return rest.length ? null : { mode: 'sleep' };
+    case 'fly': return rest.length ? null : { mode: 'fly' };
+    case 'ask': return { mode: 'ask', question: rest.join(' ').trim() };
+    // Anything else is a question for the dragon, never a usage error.
+    default: return { mode: 'ask', question: t };
+  }
+}
+
+// ---- sleep: katakana veil ---------------------------------------------------------------------------------
+export const VEIL_IN_MS = 700;           // text drops into katakana, left to right
+export const VEIL_STEP_MS = 700;         // the noise re-rolls this slowly (low frame rate; a shimmer, not a flicker)
+export const WAKE_MS = Math.round(revealSpan(TIMING.row) * 1000); // the existing decode reveal, run forward
+
+const isText = (ch) => /^[\p{L}\p{N}\p{P}\p{S}]+$/u.test(ch);
+const kana = (i, k, salt) => SCRAMBLE_GLYPHS[Math.floor(hash3(i, k, salt) * SCRAMBLE_GLYPHS.length)];
+
+/**
+ * One source line as veil cells at `ms` since sleep began (phase 'in' then 'asleep') or since wake began
+ * (phase 'wake'). Cells are { ch, kind: 'kana'|'plain'|'blank'|'glow', g }. Width of every column is preserved
+ * (a 2-wide char becomes two kana), so rows never change length. still: no re-rolling.
+ */
+export function veilRow(text, ms, { phase = 'asleep', still = false, salt = 1, row = 0 } = {}) {
+  if (phase === 'wake') return revealCells(text, ms / 1000, TIMING.row, { salt: salt + row }).map((c) => ({ ...c }));
+  const gs = graphemes(String(text ?? '')).map((g) => g.text);
+  const n = gs.length, bucket = still ? 0 : Math.floor(ms / VEIL_STEP_MS);
+  const edge = phase === 'in' && !still ? (ms / VEIL_IN_MS) * n : Infinity; // cells left of the edge are veiled
+  const out = [];
+  gs.forEach((ch, i) => {
+    const w = stringWidth(ch);
+    if (w === 0) return;
+    if (ch === ' ' || !isText(ch) || i > edge) { out.push({ ch, kind: 'plain', g: 0 }); return; }
+    for (let k = 0; k < w; k++) out.push({ ch: kana(i * 2 + k + row * 131, bucket, salt), kind: 'kana', g: hash3(i, bucket + 7, salt) });
+  });
+  return out;
+}
+
+export const veilText = (cells) => cells.map((c) => c.ch).join('');
+export const isVeiled = (cells) => cells.some((c) => c.kind === 'kana');
+
+/** The visible text the screen shows, as at most `rows` lines wrapped to `cols` (tail of the transcript). */
+export function sourceLines(s, cols, rows) {
+  const all = [...(s?.history || []), ...(s?.blocks || [])];
+  const lines = [];
+  for (let i = all.length - 1; i >= 0 && lines.length < rows; i--) {
+    const it = all[i];
+    const t = it.kind === 'user' ? `> ${it.text || ''}` : itemText(it);
+    if (!t.trim()) continue;
+    const wrapped = [];
+    for (const raw of t.split('\n')) {
+      let r = raw;
+      if (!r) { wrapped.push(''); continue; }
+      while (stringWidth(r) > cols) { let cut = cols; while (cut > 1 && stringWidth(r.slice(0, cut)) > cols) cut--; wrapped.push(r.slice(0, cut)); r = r.slice(cut); }
+      wrapped.push(r);
+    }
+    lines.unshift(...wrapped);
+  }
+  return lines.slice(-rows);
+}
+
+// ---- the sleep screen -----------------------------------------------------------------------------------------
+export const SLEEP_HINT = 'asleep · any key wakes · /back when you return';
+const VEIL_RGB = [129, 140, 248], HINT_RGB = [186, 230, 253];
+
+/**
+ * The whole sleep frame as rows of { ch, rgb } cells, `rows` tall and `cols` wide. ms = since sleep began, or
+ * since wake began when wake is true (text decodes back, the dragon is gone). Pure: no transcript access, the
+ * caller passes the source lines. still (reduced motion): a static veil and a still dragon. mono: no colour.
+ */
+export function composeSleep({ lines, cols, rows, ms = 0, wake = false, still = false, mono = false, theme = 'dark', size }) {
+  const phase = wake ? 'wake' : ms < VEIL_IN_MS && !still ? 'in' : 'asleep';
+  const col = (c) => (mono ? null : c);
+  const grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ({ ch: ' ', rgb: null })));
+  const body = wake ? rows : rows - 1; // the last row holds the wake hint while asleep
+  const src = lines.slice(-body);
+  const top = body - src.length;
+  src.forEach((line, i) => {
+    veilRow(line, ms, { phase, still, row: i }).slice(0, cols).forEach((c, x) => {
+      grid[top + i][x] = { ch: c.ch, rgb: c.kind === 'kana' ? col(VEIL_RGB) : null, bold: c.kind === 'glow' && c.g > 0.5 };
+    });
+  });
+  if (!wake) {
+    const sz = size ?? (rows >= 32 && cols >= 64 ? undefined : 'mid');
+    const dcols = Math.min(cols, sz === 'mid' || cols < 64 ? 44 : 72);
+    const dc = sleepCells(ms, dcols, undefined, { theme, mono, still, size: sz });
+    const x0 = Math.max(0, Math.floor((cols - dcols) / 2)), y0 = Math.max(0, Math.floor((rows - 1 - dc.length) / 2));
+    dc.forEach((r, i) => {
+      if (y0 + i >= rows - 1) return;
+      r.forEach((c, x) => { if (x0 + x < cols) grid[y0 + i][x0 + x] = { ch: c.ch, rgb: mono ? null : c.rgb, bg: c.bg || undefined }; });
+    });
+    const hint = [...SLEEP_HINT], hx = Math.max(0, Math.floor((cols - hint.length) / 2));
+    hint.forEach((ch, i) => { if (hx + i < cols) grid[rows - 1][hx + i] = { ch, rgb: col(HINT_RGB) }; });
+  }
+  return grid;
+}

package/lib/quoxon/dragonMoments.js

@@ -0,0 +1,82 @@
+/**
+ * ONE moment engine for both dragon systems. A "moment" is a stream fact worth a dragon: an approval is waiting, a turn or the
+ * stream failed, a long turn finished, a turn finished. The classification (and its dedupe) lives here once; the table says what
+ * each moment calls: `mood` is the Q dragon's cinematic clip (qmotion playDragon), `companion` is whether an attached companion
+ * dragon shows itself. The controller (dragonCompanion.js) runs the engine on every stream fact and owns the routing: while a
+ * companion owns the moments the Q dragon stays quiet, so a moment is never two dragons.
+ */
+export const MOMENTS = Object.freeze({
+  approval: Object.freeze({ mood: 'waiting', companion: true }),
+  failure: Object.freeze({ mood: 'failure', companion: true }),
+  long: Object.freeze({ mood: 'success', companion: true }),
+  success: Object.freeze({ mood: 'success', companion: false }),
+});
+/** A turn at least this long counts as a "long task" when it finishes. */
+export const LONG_TASK_MS = 30000;
+
+export function createMomentEngine({ now = Date.now } = {}) {
+  const seen = new Set();
+  let turnStart = null;
+  const moment = (kind) => ({ kind, ...MOMENTS[kind] });
+  return {
+    turnStarted() { turnStart = now(); },
+    reset() { seen.clear(); turnStart = null; },
+    /** A reducer event (the companion's vocabulary) -> { kind, mood, companion } | null. */
+    observe(ev) {
+      if (!ev) return null;
+      if (ev.type === 'approval.requested') {
+        // The same approval arrives twice (the stream event, then the inbox poll) under different ids: one moment for it.
+        const keys = [ev.call_id, ev.inbox_item_id, ev.approval_id].filter(Boolean).map(String);
+        if (keys.some(k => seen.has(k))) return null;
+        keys.forEach(k => seen.add(k));
+        return moment('approval');
+      }
+      if (ev.type === 'error') return moment('failure');
+      if (ev.type === 'turn.finished') {
+        const started = turnStart; turnStart = null;
+        if (ev.status === 'failed' || ev.status === 'unconfirmed') return moment('failure');
+        if (ev.status !== 'completed') return null;
+        return moment(started != null && now() - started >= LONG_TASK_MS ? 'long' : 'success');
+      }
+      return null;
+    },
+  };
+}
+
+// ---- domain moments: a fact from the estate summons the matching dragon (companion mode `on` only) ------------------------
+/** A dragon summoned by a domain moment cannot be summoned again for this long. */
+export const SUMMON_COOLDOWN_MS = 60000;
+
+/**
+ * An objective or loop roster row -> { dragon, caption } when it has finished or failed, else null. The caption states only
+ * what the row says. The roster row carries no agent, so the dragon is Seer (the plan dragon); an agent field would pick its own.
+ */
+export function objectiveMoment(row) {
+  if (!row || (row.kind !== 'objective' && row.kind !== 'loop') || (row.state !== 'done' && row.state !== 'failed')) return null;
+  const noun = row.kind === 'loop' ? 'Loop' : 'Objective', name = row.name || row.id;
+  const caption = row.state === 'done' ? `${noun} finished: ${name}.` : `${noun} failed: ${name}${row.activity ? ` (${row.activity})` : ''}.`;
+  return { dragon: 'seer', caption };
+}
+
+/**
+ * Watches roster rows and reports each objective/loop that was seen unfinished and is now done or failed, once. The first
+ * observation is a baseline (rows already finished at startup never fire); a reported key is retired for good.
+ */
+export function createRosterWatch() {
+  const active = new Set(), retired = new Set();
+  let primed = false;
+  return {
+    observe(rows = []) {
+      const out = [];
+      for (const r of rows) {
+        if (!r || (r.kind !== 'objective' && r.kind !== 'loop') || retired.has(r.key)) continue;
+        if (r.state === 'done' || r.state === 'failed') {
+          if (active.delete(r.key) && primed) { const m = objectiveMoment(r); if (m) out.push(m); }
+          retired.add(r.key);
+        } else active.add(r.key);
+      }
+      primed = true;
+      return out;
+    },
+  };
+}

package/lib/quoxon/dragonReads.js

@@ -0,0 +1,68 @@
+/**
+ * The reads behind the dragon jobs (lib/dragon/jobs.js). Each is the same call a `quox` verb already makes, read-only,
+ * bounded, retries off. The CLI client throws on a non-2xx, so a throw is the failure and a returned body is checked for the
+ * error shapes some routes use with a 200 (success:false). Nothing here turns an error into a count.
+ */
+import { resolveEndpoint } from '../api/endpoints.js';
+import { healthOf } from './objects/fleet.js';
+
+const TIMEOUT = 5000;
+const STATE = { 1: 'up', 0: 'down', 2: 'pending', 3: 'maintenance' };
+const kumaState = (m) => (m && typeof m.state === 'string' ? m.state : m && Object.hasOwn(STATE, m.status) ? STATE[m.status] : 'unknown'); // same mapping as `quox kuma`
+const whyOf = (e) => (e?.status ? `HTTP ${e.status}` : /timed out/i.test(e?.message || '') ? 'timed out' : e?.message || 'failed');
+
+export function createDragonReads({ client }) {
+  const get = (name, params, query) => { const ep = resolveEndpoint(name, params); return client.get(ep.path, { service: ep.service, query, retries: 0, timeout: TIMEOUT }); };
+  return {
+    /** WARD inclusion receipt of one envelope (POST /ward/verify-receipt, the route /proof uses). -> { ok, result } | { ok:false, error } */
+    async verifyReceipt(envelopeId) {
+      try {
+        const d = await client.post('/ward/verify-receipt', { service: 'collector', body: { source_id: envelopeId, source_kind: 'AEE' }, retries: 0, timeout: TIMEOUT });
+        return { ok: true, result: d?.result || d };
+      } catch (e) { return { ok: false, error: whyOf(e) }; }
+    },
+    /** `quox kuma` live read -> { up, down, total, avgPing, downNames, ageSeconds } */
+    async routes() {
+      const d = await get('mon.kuma.live.get');
+      if (d?.success === false) throw new Error(`kuma returned an error body: ${d.error || 'no detail'}`);
+      if (!Array.isArray(d?.monitors)) throw new Error('kuma answered with no monitors list');
+      const ms = d.monitors;
+      const up = ms.filter(m => kumaState(m) === 'up'), down = ms.filter(m => kumaState(m) === 'down');
+      const pings = up.filter(m => m.ping != null).map(m => Number(m.ping)).filter(Number.isFinite); // a null ping is no measurement, not 0 ms
+      return { up: up.length, down: down.length, total: ms.length, avgPing: pings.length ? pings.reduce((a, b) => a + b, 0) / pings.length : null, downNames: down.map(m => m.name || `monitor ${m.id}`), ageSeconds: Number.isFinite(d.ageSeconds) ? d.ageSeconds : null };
+    },
+    /** `quox plan focus` -> { id, done, total } of the first focus stream; null when nothing is in focus or there is no roadmap. */
+    async plan() {
+      const rms = (await get('quoxplan.roadmaps.list'))?.roadmaps;
+      if (!Array.isArray(rms)) throw new Error('quoxplan answered with no roadmaps list');
+      if (!rms.length) return null;
+      const streams = (await get('quoxplan.roadmap.streams.list', { roadmapId: rms[0].id }, { lens: 'focus' }))?.streams;
+      if (!Array.isArray(streams)) throw new Error('quoxplan answered with no streams list');
+      if (!streams.length) return null;
+      // The first few focus streams, in the server's order: the first one that has phases gives "x of y". A stream with none (a meta
+      // stream) or whose phases could not be read is only named, never given a made-up count.
+      const top = streams.slice(0, 3);
+      const details = await Promise.allSettled(top.map(t => get('quoxplan.stream.get', { id: t.id })));
+      const rows = top.map((t, i) => {
+        const phases = details[i].status === 'fulfilled' && Array.isArray(details[i].value?.phases) ? details[i].value.phases : null;
+        return phases ? { id: t.id, done: phases.filter(p => p.done_at || /^(done|complete)/i.test(String(p.status || ''))).length, total: phases.length } : { id: t.id, done: null, total: null };
+      });
+      return rows.find(r => r.total > 0) || rows[0];
+    },
+    /** `quox fleet hosts` rows bucketed by health. */
+    async fleet() {
+      const d = await get('v1.fleet.hosts.list');
+      const hosts = Array.isArray(d) ? d : d?.hosts;
+      if (!Array.isArray(hosts)) throw new Error('unexpected fleet response');
+      const c = { total: hosts.length, healthy: 0, degraded: 0, unhealthy: 0, offline: 0, unknown: 0 };
+      for (const h of hosts) c[healthOf(h)]++;
+      return c;
+    },
+    /** The org's open security findings (engagement store). */
+    async findings() {
+      const d = await get('engagement.findings.open', {});
+      if (!Array.isArray(d?.findings)) throw new Error('unexpected findings response');
+      return { open: d.findings.length, severe: d.findings.filter(f => /^(critical|high)$/i.test(String(f.severity || ''))).length };
+    },
+  };
+}

package/lib/quoxon/dragonView.js

@@ -0,0 +1,41 @@
+/** Ink views for /dragon explain|ask (the talking dragon) and /dragon sleep (the screensaver). Frames come from dragonModes.js. */
+import React from 'react';
+import { Box, Text } from 'ink';
+import { cellNodes } from './qmotion.js';
+import { composeSleep } from './dragonModes.js';
+import { pickCells } from './qdragonScenes.js';
+import { flyFrame, flyCols } from './qdragonFly.js';
+import { mono, isLight, clip } from './theme.js';
+import { useFrame } from './motion/frame.js';
+
+const h = React.createElement;
+
+/** The sleep screen: the whole live region while asleep (and for the decode on wake). Reads the clock itself. */
+export function SleepScreen({ lines, cols, rows, startedAt, wakeAt = null, still = false }) {
+  useFrame();
+  const now = Date.now();
+  const wake = wakeAt != null;
+  const ms = wake ? now - wakeAt : now - startedAt;
+  const grid = composeSleep({ lines, cols, rows, ms, wake, still, mono: mono(), theme: isLight() ? 'light' : 'dark' });
+  return h(Box, { flexDirection: 'column' }, ...grid.map((r, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(r, `s${k}-`))));
+}
+
+/** The compact dragon beside an explain/ask answer: the mouth works while text streams, then it rests with idle eyes. */
+export function DragonTalk({ cols, label, talking, since, still = false }) {
+  useFrame();
+  const dcols = Math.min(cols, 44);
+  const t = Date.now() - since;
+  const cells = pickCells(t, dcols, undefined, { theme: isLight() ? 'light' : 'dark', mono: mono(), still: still || !talking, talk: talking && !still, size: 'mid', mouthSide: 'right' });
+  return h(Box, { flexDirection: 'column', marginTop: 1 },
+    ...cells.map((row, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(row, `t${k}-`))),
+    h(Text, null, clip(label, Math.max(10, cols - 2))));
+}
+
+/** /dragon-fly: one pass of the dragon in flight across the live region (qdragonFly.js). `still`: a single frame, no motion. */
+export function FlyLive({ cols, rows, startedAt, still = false, chromeH = null }) {
+  useFrame();
+  const c = flyCols(cols);
+  const cells = flyFrame(Date.now() - startedAt, c, { still, mono: mono(), theme: isLight() ? 'light' : 'dark', termRows: rows, chromeH });
+  return h(Box, { flexDirection: 'column', marginTop: 1 },
+    ...cells.map((row, k) => h(Text, { key: k, wrap: 'truncate' }, ...cellNodes(row, `f${k}-`))));
+}

package/lib/quoxon/earlyInput.js

@@ -0,0 +1,40 @@
+/**
+ * Keys typed before the app is ready (R3 audit D4). bin/quox.js calls this before it loads React, Ink or any
+ * command module, so the tty is raw (no cooked echo) and every key is kept for the composer. main() calls it
+ * again and gets the same capture. Tiny on purpose: it must not import anything heavy.
+ *
+ * A line typed while the tty was still cooked reaches us when raw mode turns on, with the kernel's ICRNL
+ * having turned its Enter into LF; that first read is mapped back to CR so the Enter submits as typed.
+ */
+import { PASTE_ON, PASTE_OFF } from './keys.js';
+
+const COOKED_MS = 50; // the read that drains the cooked line buffer arrives right after raw mode turns on
+let shared = null;
+
+export function captureEarlyInput(stdin = process.stdin, stdout = process.stdout) {
+  const own = stdin === process.stdin;
+  if (own && shared) return shared;
+  if (!stdin?.isTTY) return null;
+  const chunks = [];
+  const t0 = Date.now();
+  const fn = (d) => {
+    const s = typeof d === 'string' ? d : d.toString('utf8');
+    chunks.push(Date.now() - t0 < COOKED_MS ? s.replace(/\n/g, '\r') : s);
+  };
+  try { stdin.setRawMode?.(true); stdin.resume?.(); } catch { /* not a tty after all */ }
+  stdin.on('data', fn);
+  if (stdout?.isTTY) stdout.write(PASTE_ON);
+  const cap = {
+    chunks,
+    detach: () => stdin.off('data', fn),
+    /** Nothing will take the terminal over (help, a flag error): give it back as it was. */
+    release: () => {
+      stdin.off('data', fn);
+      try { stdin.setRawMode?.(false); stdin.pause?.(); } catch { /* ignore */ }
+      if (stdout?.isTTY) stdout.write(PASTE_OFF);
+      if (own) shared = null;
+    }
+  };
+  if (own) shared = cap;
+  return cap;
+}

package/lib/quoxon/echo.js

@@ -0,0 +1,15 @@
+// Echo of a command the human typed, shown in the scrollback like a prompt line (wrapped in full, secrets masked).
+// Owner 2026-10-15: "why truncated": the echo wraps like any prompt; only a runaway paste is capped.
+import { redactSecrets } from './slotChat.js';
+import { clip } from './theme.js';
+
+const PIN_CMD = /^\/(authenticate|authorise|authorize)(\s|$)/i;
+
+/** -> { shown, full }: `shown` is the whole command on one logical line (the view wraps it; capped at ECHO_CAP), `full` is the masked text the transcript records. */
+export const ECHO_CAP = 2000;
+export function echoLine(text, { cols = 100 } = {}) {
+  let t = String(text ?? '').trim();
+  if (PIN_CMD.test(t)) t = t.split(/\s+/)[0]; // a stray argument may be a PIN: never shown
+  const full = redactSecrets(t).text;
+  return { shown: clip(full.replace(/\s*\n\s*/g, ' '), ECHO_CAP), full };
+}

package/lib/quoxon/egg.js

@@ -1,7 +1,7 @@
 /**
- * The Dragon's Eye launch Easter egg (CLI-QUOX). On launch the settled Q opens its eye and blinks, rarely:
+ * The launch Easter egg (CLI-QUOX). On launch the v8 dragon greets you (googly eyes open, blink, smile), rarely:
  * 1 in EGG_ODDS launches, never twice in a row, never in --print, under reduced motion or off a TTY.
- * /eye plays it on demand, and the cinematic motion level always may.
+ * /dragon plays it on demand, and the cinematic motion level always may.
  *
  * pickLaunchEgg is pure; launchEgg adds the one bit of persistence (did the last launch show the eye?) in
  * ~/.config/quox/motion.json. QUOX_EGG=eye forces it (demos, captures); QUOX_EGG=off disables it.