quoxcli 0.0.0-stage → 0.3.1

package/lib/quoxon/indicator.js

@@ -0,0 +1,197 @@
+/**
+ * Perpetual status indicator model (CLI-QUOX): a one-cell Q whose COLOUR carries state.
+ *   resting  dim sky, slow breathing        working  sky <-> violet shimmer (katakana rain beside it)
+ *   waiting  amber pulse (needs approval)   failing  red, static
+ * The glyph is Ⓠ (U+24C0, the documented Quox stand-in): compared in xterm.js against `◖Q`, `Q` and `◖Q◗`
+ * it was the only one that reads as a Q at a glance in every colour; the bare Q is lost beside text and
+ * the half-circle forms look like a bullet. Pure functions, tick t advances every 120 ms.
+ */
+export const Q_GLYPH = 'Ⓠ';
+export const STATES = ['resting', 'working', 'waiting', 'failing'];
+const SKY = [56, 189, 248], VIOLET = [168, 85, 247], AMBER = [245, 158, 11], RED = [239, 68, 68];
+const mix = (a, b, t) => a.map((v, i) => Math.round(v + (b[i] - v) * t));
+const tri = (t, period) => { const k = (t % period) / period; return k < 0.5 ? k * 2 : 2 - k * 2; };
+
+/** working / waiting / failing from what the app knows; Working is only mounted while a turn runs. */
+export function indicatorState(activity, failing = false) {
+  if (failing) return 'failing';
+  if (/^waiting for approval/i.test(String(activity || ''))) return 'waiting';
+  return 'working';
+}
+
+/** rgb for the Q at tick t. quiet (reduced motion) freezes the animation at a representative colour. */
+export function qColor(state, t = 0, quiet = false) {
+  switch (state) {
+    case 'resting': return mix([40, 70, 90], SKY, quiet ? 0.5 : 0.25 + 0.5 * tri(t, 20));
+    case 'waiting': return mix([120, 76, 6], AMBER, quiet ? 1 : 0.3 + 0.7 * tri(t, 10));
+    case 'failing': return RED;
+    default: return mix(SKY, VIOLET, quiet ? 0.5 : tri(t, 16));
+  }
+}
+
+/** The word shown for a state when the activity text is not the whole story. */
+export function stateWord(state, activity) {
+  if (state === 'failing') return 'Failed';
+  if (state === 'resting') return 'Ready';
+  const a = String(activity || '').replace(/[.…\s]+$/u, '');
+  return !a || a === 'Working' ? 'Thinking' : a;
+}
+
+/** 842 -> "842", 1234 -> "1.2k", 12400 -> "12k". */
+export function fmtTokens(n) {
+  n = Math.max(0, Math.round(Number(n) || 0));
+  if (n < 1000) return String(n);
+  const k = n / 1000;
+  return k < 10 ? `${k.toFixed(1).replace(/\.0$/, '')}k` : `${Math.round(k)}k`;
+}
+
+/** USD for the closing line: undefined (omit) when absent, zero or not a number; never invented. */
+export function fmtCost(usd) {
+  const v = Number(usd);
+  if (!Number.isFinite(v) || v <= 0) return null;
+  return `$${v < 0.01 ? v.toFixed(4) : v.toFixed(2)}`;
+}
+
+/**
+ * Normalise a server usage object. Real numbers only: { tokens, cost } with null for anything missing.
+ * tokens = output tokens (what streamed back); falls back to input+output only when no split is given.
+ */
+export function normUsage(u, doneCost) {
+  const o = (u && typeof u === 'object') ? u : {};
+  const out = o.output_tokens ?? o.completion_tokens;
+  const inp = o.input_tokens ?? o.prompt_tokens;
+  const total = o.total_tokens;
+  const tokens = Number.isFinite(Number(out)) && out != null ? Number(out)
+    : Number.isFinite(Number(total)) && total != null ? Number(total)
+    : Number.isFinite(Number(inp)) && inp != null ? Number(inp) : null;
+  // cost_source 'claude-cli': the claude CLI's own API-equivalent estimate on the subscription path, not a price.
+  const costSource = typeof o.cost_source === 'string' ? o.cost_source : null;
+  const cost = Number(o.cost_usd ?? doneCost);
+  return { tokens, cost: !costSource && Number.isFinite(cost) && cost > 0 ? cost : null, real: tokens != null, costSource };
+}
+
+/** Live token figure: the real number once the server reported it, else an estimate from received text (~chars/4). */
+export function turnTokens(turn) {
+  if (!turn) return 0;
+  if (turn.usage?.real) return turn.usage.tokens;
+  return Math.ceil((turn.chars || 0) / 4);
+}
+
+/**
+ * Glyphs that stand in for letters while the word "decrypts" (owner 2026-10-12: far more variety). Half-width
+ * katakana only: one cell each, the width of a Latin letter, so the word never jitters. 42 of them: the whole
+ * U+FF66..U+FF9D block minus forms that read as a Latin letter, digit, bracket or bare box/stroke in DejaVu
+ * Sans Mono fallback (ｪｴ like I/E, ｭｮﾕﾖ boxes, ﾆ "=", ﾉ "/", ﾌ "7", ﾍ "^", ﾘ "U", ﾚ "L", ﾛ a box, ｰ a dash)
+ * and the voiced marks ﾞ ﾟ.
+ */
+/** Decode glyphs: every half-width katakana (U+FF66-FF9D, one cell each, minus the long-vowel bar ｰ) plus the
+ * code-rain digits. Owner 2026-10-15: the reveal felt like "just a few characters" with 44 look-alike kana. */
+export const SCRAMBLE_GLYPHS = 'ｦｧｨｩｪｫｬｭｮｯｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜﾝ0123456789';
+
+/** Deterministic hash in [0,1). */
+const hsh = (a, b, c = 0) => { let x = (a * 374761393 + b * 668265263 + c * 2147483647) | 0; x = Math.imul(x ^ (x >>> 13), 1274126177); return ((x ^ (x >>> 16)) >>> 0) / 4294967296; };
+
+/** Per-cell flicker period (ms), 60..180, so cells never pulse in lockstep. */
+export const cellPeriod = (i, seed = 0) => 60 + Math.floor(hsh(i, 911, seed) * 121);
+export const SCRAMBLE_CHANCE = 0.5; // x mean cascade 3/5 of an episode -> ~30% of letters scrambled at any time
+const EPISODE = 5;                  // an episode is 5 flicker periods: a cascade of 2..4 glyphs, then the letter
+const FLASH_MS = 90;                 // one frame of bright flash when a cell resolves
+
+/**
+ * Glyph for cell i in flicker bucket k. Even and odd buckets draw from disjoint halves of the set, so a cell
+ * never shows the same glyph twice in a row.
+ */
+export function cellGlyph(i, k, seed = 0) {
+  const half = Math.floor(SCRAMBLE_GLYPHS.length / 2);
+  const odd = ((k % 2) + 2) % 2;
+  return SCRAMBLE_GLYPHS[odd * half + Math.floor(hsh(i, k, seed) * half)];
+}
+
+/**
+ * The activity word at time `now` (ms): "Matrix rain through the word". Pure. Returns [{ ch, glyph, flash }].
+ *   decode-in: a word that just changed (at `since`) resolves left to right over DECODE_MS (unresolved = glyph)
+ *   steady:    each letter runs its own clock (cellPeriod); per episode of 4 periods it is either plain or
+ *              cascades through 2..4 different glyphs and resolves with one bright flash frame
+ * Spaces are never scrambled; every cell is one column, so the width never changes.
+ */
+export function wordFrame(word, now, { since = -Infinity, seed = 0 } = {}) {
+  const chars = [...String(word)];
+  const letters = chars.filter(ch => ch.trim()).length;
+  let li = -1;
+  return chars.map((ch, i) => {
+    if (!ch.trim()) return { ch, glyph: false, flash: false };
+    li++;
+    const P = cellPeriod(i, seed), phase = Math.floor(hsh(i, 313, seed) * P * EPISODE);
+    const tt = now + phase, k = Math.floor(tt / P);
+    const decodeAt = since + ((li + 1) / letters) * DECODE_MS;
+    if (now < decodeAt) return { ch: cellGlyph(i, k, seed), glyph: true, flash: false };
+    if (now - decodeAt < FLASH_MS) return { ch, glyph: false, flash: true }; // resolve flash on decode-in too
+    if (now < since + DECODE_MS + 200) return { ch, glyph: false, flash: false }; // a fresh word reads cleanly first
+    const E = Math.floor(k / EPISODE), pos = k - E * EPISODE;
+    const cascade = (e) => (hsh(i, e, seed + 17) < SCRAMBLE_CHANCE ? 2 + Math.floor(hsh(i, e, seed + 29) * 3) : 0);
+    const m = cascade(E);
+    if (pos < m) return { ch: cellGlyph(i, k, seed), glyph: true, flash: false };
+    const resolvedAt = (E * EPISODE + m) * P;
+    if (m > 0 && pos === m && tt - resolvedAt < Math.min(P, FLASH_MS)) return { ch, glyph: false, flash: true };
+    return { ch, glyph: false, flash: false };
+  });
+}
+
+/** Gradient stops per state for the coloured word (same families as the composer ring). */
+export const WORD_PALETTES = {
+  working: [SKY, VIOLET, [6, 182, 212]],
+  writing: [[34, 197, 94], [74, 222, 128], [20, 184, 166]],
+  waiting: [AMBER, [234, 88, 12], [251, 191, 36]],
+  failing: [RED, RED, RED],
+};
+/**
+ * Colour of a word cell: one gradient sweeping across the word over time (~1.6 s per pass). Resolved letters
+ * are slightly brighter than glyphs; a flash is near white. quiet (reduced motion) freezes the sweep.
+ */
+export function wordColor(state, i, n, now, kind = 'letter', quiet = false) {
+  const pal = WORD_PALETTES[state] || WORD_PALETTES.working;
+  const u = ((((n > 1 ? i / (n - 1) : 0) * 0.65 - (quiet ? 0 : now / 1600)) % 1) + 1) % 1;
+  const x = u * pal.length, a = Math.floor(x) % pal.length, b = (a + 1) % pal.length;
+  const base = mix(pal[a], pal[b], x - Math.floor(x));
+  if (kind === 'flash') return mix(base, [255, 255, 255], 0.7);
+  if (kind === 'glyph') return mix(base, [30, 36, 48], 0.28);
+  return mix(base, [255, 255, 255], 0.12);
+}
+
+/**
+ * Previous model (kept for the drop-in reveal and existing callers): one frame with a random 30-45% of the
+ * letter positions scrambled. Returns [{ ch, glyph }]. rand is injectable for tests.
+ */
+export function scrambleFrame(word, rand = Math.random) {
+  const chars = [...String(word)];
+  const idx = chars.map((c, i) => (c.trim() ? i : -1)).filter((i) => i >= 0);
+  const chosen = new Set();
+  if (idx.length > 1) {
+    const k = Math.min(idx.length - 1, Math.max(1, Math.round(idx.length * (0.3 + 0.15 * rand()))));
+    const pool = [...idx];
+    while (chosen.size < k) chosen.add(pool.splice(Math.floor(rand() * pool.length), 1)[0]);
+  }
+  return chars.map((ch, i) => (chosen.has(i) ? { ch: SCRAMBLE_GLYPHS[Math.floor(rand() * SCRAMBLE_GLYPHS.length)], glyph: true } : { ch, glyph: false }));
+}
+/** Shimmer colour for the glyph at position i, tick t (sky to violet). */
+export const glyphColor = (i, t) => mix(SKY, VIOLET, tri(t + i * 2, 16));
+
+export const DECODE_MS = 300;
+/**
+ * A word that just changed decodes in: letters resolve left to right over DECODE_MS. Unresolved positions
+ * are always glyphs; resolved ones follow the normal 30-45% scramble. progress 0..1 (>=1 = steady state).
+ */
+export function decodeFrame(word, progress, rand = Math.random) {
+  const base = scrambleFrame(word, rand);
+  if (progress >= 1) return base;
+  const n = base.filter((g) => g.ch.trim()).length;
+  let seen = 0;
+  const revealed = Math.floor(clamp01(progress) * n);
+  return base.map((g) => {
+    if (!g.ch.trim()) return g;
+    const i = seen++;
+    if (i < revealed) return g;
+    return g.glyph ? g : { ch: SCRAMBLE_GLYPHS[Math.floor(rand() * SCRAMBLE_GLYPHS.length)], glyph: true };
+  });
+}
+const clamp01 = (x) => Math.max(0, Math.min(1, x));

package/lib/quoxon/intent.js

@@ -0,0 +1,52 @@
+/**
+ * Local intent hints. When a message is plainly a client command in words, the turn is NOT intercepted
+ * (the model still answers); the client only prints one dim `tip: /command` line above the answer.
+ * Exact, anchored patterns on the whole message: anything with extra words is ordinary chat.
+ */
+const WORD = '([A-Za-z0-9][\\w.-]{0,39})';
+// Questions answered by a local panel (/context, /cost, /status): the panel prints above the answer.
+const PANELS = [
+  [/^(?:how much (?:of (?:the|my|our) )?context (?:have (?:we|i) used|has been used|is (?:used|left)|are we using|am i using|do (?:we|i) have left)|what(?:'s| is) (?:the|my|our) context(?: usage)?|context usage)$/i, '/context'],
+  [/^(?:what(?:'s| is) (?:this|it) costing(?: (?:me|us))?|how much (?:has|did) (?:this|it) cost(?: (?:me|us))?(?: so far)?|how much (?:have (?:i|we)|am i|are we) spen(?:t|ding)(?: so far)?|what(?:'s| is| has been) (?:the|my|our) (?:cost|spend|usage)(?: so far)?)$/i, '/cost'],
+  [/^(?:what(?:'s| is) my status|what(?:'s| is) the status|show (?:me )?my status|status)$/i, '/status']
+];
+function PANEL_RULES() { return PANELS.map(([re, cmd]) => [re, () => cmd]); }
+
+const RULES = [
+  // owner 2026-10-15: "attach to TRIAGE-Q agent" / "reattach to ..." took four turns; the tip must catch them
+  [new RegExp(`^(?:please )?(?:re)?attach(?: me)?(?: to)?(?: the)? ${WORD}(?: agent)?(?: please)?$`, 'i'), (m) => `/attach ${m[1].toLowerCase()}`],
+  [/^rename (?:this|the|my) (?:session|conversation|chat) (?:to|as) ([\w.-]+(?: [\w.-]+){0,2})$/i, (m) => m[1].split(' ').some(w => /^(and|then|but|so|please)$/i.test(w)) ? null : `/rename ${m[1]}`],
+  [/^(?:what(?:'s| is) running|what is running now)$/i, () => '/roster'],
+  [/^(?:show|list|open) (?:my |the )?(?:pending )?approvals$/i, () => '/approvals'],
+  [/^(?:what(?:'s| is)|show me what(?:'s| is)) (?:waiting|pending) (?:for )?(?:my )?approval$/i, () => '/approvals'],
+  [/^(?:so )?(?:what (?:did i miss|have i missed)(?: (?:while|when) i was (?:away|out|gone|offline))?|what (?:happened|changed) (?:while|when) i was (?:away|out|gone|offline)|(?:did )?anything happen(?:ed)? while i was (?:away|out|gone|offline)|catch me up)$/i, () => '/away'],
+  [/^(?:(?:give me |show me |can i get )?(?:a |the )?sit ?rep(?: please)?|what(?:'s| is) the situation(?: now)?|situation report(?: please)?)$/i, () => '/sitrep'],
+  [/^(?:how(?:'s| is) (?:the |my |our )?fleet(?: doing)?|(?:show|list) (?:me )?(?:the |my |our )?fleet|fleet (?:status|health)|what(?:'s| is) (?:the )?(?:state|health) of (?:the |my |our )?(?:fleet|computers|servers))$/i, () => '/fleet'],
+  [/^(?:open|show|take me to|go to) (?:me )?(?:to )?(?:the |my )?(?:quox )?(?:web )?dashboard$/i, () => '/dashboard'],
+  [/^detach(?: from (?:the )?agent)?$/i, () => '/detach'],
+  [/^(?:clear|cls|clear (?:the )?screen)$/i, () => '/clear'], // owner typed bare "clear" (2026-10-15)
+  [/^(?:start )?(?:a )?new conversation$/i, () => '/new'],
+  [/^(?:please )?(?:compact|summari[sz]e and compact|compress) (?:this|the|our|my) (?:conversation|chat|session|context)(?: please)?$/i, () => '/compact'],
+  [/^(?:please )?(?:update|upgrade) (?:the |my |this )?(?:quox )?(?:server|install|instance|quox)(?: (?:to (?:the )?latest|please))?$/i, () => 'quox server update --dry-run (in a terminal; shows the plan first)'],
+  [/^(?:please )?roll ?back (?:the |my |this )?(?:quox )?(?:server|install|instance|update)$/i, () => 'quox server rollback --dry-run (in a terminal)'],
+  [/^(?:please )?uninstall (?:the |my |this )?(?:quox )?(?:server|install|instance|quox)$/i, () => 'quox server uninstall --dry-run (in a terminal; lists what goes first)'],
+  [/^(?:what version is (?:the |my )?(?:quox )?server(?: on| running)?|is (?:the |my )?(?:quox )?server (?:up to date|healthy)|server status)$/i, () => '/server'],
+  [/^(?:make|create|write) (?:a )?(?:support|diag(?:nostic)?s?) bundle$/i, () => 'quox server diag (in a terminal; written locally, never uploaded)'],
+  ...PANEL_RULES()
+];
+
+/** -> `tip: /attach seer` or null. */
+export function intentHint(text) {
+  const t = String(text || '').trim().replace(/[.?!]+$/, '').trim();
+  if (!t || t.includes('\n') || t.startsWith('/')) return null;
+  for (const [re, fmt] of RULES) { const m = re.exec(t); const r = m && fmt(m); if (r) return `tip: ${r}`; }
+  return null;
+}
+
+/** -> '/context' | '/cost' | '/status' when the message asks a question a local panel answers, else null. */
+export function intentPanel(text) {
+  const t = String(text || '').trim().replace(/[.?!]+$/, '').trim();
+  if (!t || t.includes('\n') || t.startsWith('/')) return null;
+  for (const [re, cmd] of PANELS) if (re.test(t)) return cmd;
+  return null;
+}

package/lib/quoxon/keys.js

@@ -0,0 +1,164 @@
+/**
+ * Raw stdin tokeniser for the QUOXON composer. We own input parsing (instead of
+ * Ink's useInput) because we need bracketed paste, Shift+Enter, Ctrl+_ and a
+ * paste-burst heuristic, none of which Ink 6 exposes.
+ *
+ * parseChunk(chunk, state) -> { events, state }
+ * Events: { type: 'text', text } | { type: 'paste', text } | { type: 'key', name, ctrl?, alt? } | { type: 'focus', focused }
+ *   | { type: 'mouse', action: 'press'|'release'|'drag'|'move'|'wheel', button, x, y, shift, alt, ctrl } (SGR 1006, QUOXON-MOUSE)
+ *   | { type: 'cursor', row, col } (a cursor position report, the answer to DSR ESC[6n)
+ */
+
+const BUTTONS = ['left', 'middle', 'right', 'none'];
+const WHEEL = ['up', 'down', 'left', 'right'];
+/** One SGR mouse report (ESC [ < b ; x ; y M|m) as an event. */
+function mouseEvent(b, x, y, final) {
+  const low = b & 3;
+  const mods = { shift: Boolean(b & 4), alt: Boolean(b & 8), ctrl: Boolean(b & 16) };
+  if (b & 64) return { type: 'mouse', action: 'wheel', button: WHEEL[low], x, y, ...mods };
+  if (b & 32) return { type: 'mouse', action: low === 3 ? 'move' : 'drag', button: BUTTONS[low], x, y, ...mods };
+  return { type: 'mouse', action: final === 'm' ? 'release' : 'press', button: BUTTONS[low], x, y, ...mods };
+}
+
+export const PASTE_ON = '\x1b[?2004h';
+export const PASTE_OFF = '\x1b[?2004l';
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+
+export const initialKeyState = () => ({ inPaste: false, pasteBuf: '', partial: '' });
+/** Time after which a dangling paste start / partial marker is flushed (app owns the timer). */
+export const PASTE_DANGLING_MS = 1500;
+/** Non-bracketed input arriving within this many ms of the previous chunk is a paste burst. */
+export const BURST_MS = 20;
+
+/** True when the key state holds something a timer must eventually flush. */
+export const hasDangling = (st) => Boolean(st?.inPaste || st?.partial);
+
+/**
+ * Flush a dangling paste start or half marker after a timeout. Buffered paste text becomes a PASTE
+ * event (inserted, never submitted); a half marker is dropped. Never produces Enter.
+ */
+export function flushDangling(state) {
+  const events = [];
+  if (state?.inPaste && state.pasteBuf) {
+    let t = state.pasteBuf;
+    for (let n = Math.min(PASTE_END.length - 1, t.length); n > 0; n--) { if (t.endsWith(PASTE_END.slice(0, n))) { t = t.slice(0, -n); break; } }
+    if (t) events.push({ type: 'paste', text: t });
+  }
+  return { events, state: initialKeyState() };
+}
+
+const CSI_KEYS = {
+  '\x1b[A': 'up', '\x1b[B': 'down', '\x1b[C': 'right', '\x1b[D': 'left',
+  '\x1bOA': 'up', '\x1bOB': 'down', '\x1bOC': 'right', '\x1bOD': 'left',
+  '\x1b[H': 'home', '\x1b[F': 'end', '\x1bOH': 'home', '\x1bOF': 'end',
+  '\x1b[1~': 'home', '\x1b[4~': 'end', '\x1b[7~': 'home', '\x1b[8~': 'end',
+  '\x1b[3~': 'delete', '\x1b[Z': 'shift-tab',
+  '\x1b[13;2u': 'shift-enter', '\x1b[27;2;13~': 'shift-enter', '\x1b\r': 'shift-enter', '\x1b\n': 'shift-enter',
+  '\x1b[1;5D': 'word-left', '\x1b[1;5C': 'word-right', '\x1b[1;3D': 'word-left', '\x1b[1;3C': 'word-right',
+  // COMPOSER-EDIT (owner 2026-10-17: edit like Claude Code's prompt box). Alt+B/F (macOS Option+Left/Right), iTerm2 Alt+arrows,
+  // Alt+Backspace, Alt+D, Ctrl/Alt+Delete, and Shift (+Ctrl/Alt) arrows, Home and End for selection.
+  '\x1bb': 'word-left', '\x1bf': 'word-right', '\x1b\x1b[D': 'word-left', '\x1b\x1b[C': 'word-right',
+  '\x1b\x7f': 'delete-word', '\x1b\x08': 'delete-word', '\x1bd': 'delete-word-forward',
+  '\x1b[3;5~': 'delete-word-forward', '\x1b[3;3~': 'delete-word-forward',
+  '\x1b[1;2D': 'select-left', '\x1b[1;2C': 'select-right', '\x1b[1;2A': 'select-up', '\x1b[1;2B': 'select-down',
+  '\x1b[1;2H': 'select-home', '\x1b[1;2F': 'select-end',
+  '\x1b[1;6D': 'select-word-left', '\x1b[1;6C': 'select-word-right', '\x1b[1;4D': 'select-word-left', '\x1b[1;4C': 'select-word-right'
+};
+const CSI_LIST = Object.keys(CSI_KEYS).sort((a, b) => b.length - a.length);
+
+const CTRL = {
+  '\x01': 'home', '\x05': 'end', '\x03': 'ctrl-c', '\x04': 'ctrl-d', '\x07': 'ctrl-g',
+  '\x0b': 'kill-line-forward', '\x0f': 'ctrl-o', '\x13': 'ctrl-s', '\x15': 'kill-line', '\x17': 'delete-word',
+  '\x1f': 'undo', '\x19': 'redo', '\x0a': 'newline', '\x7f': 'backspace', '\x08': 'backspace',
+  '\r': 'enter', '\t': 'tab', '\x02': 'left', '\x06': 'right'
+};
+
+/** `draft` = the composer text before this chunk (a burst split mid-line continues the line already typed). */
+export function parseChunk(chunk, state = initialKeyState(), draft = '') {
+  const events = [];
+  let s = String(chunk);
+  let st = { partial: '', ...state };
+  if (st.partial) { s = st.partial + s; st.partial = ''; }
+
+  while (s.length) {
+    if (st.inPaste) {
+      // search the joined buffer so an end marker split across chunks is still found
+      const buf = st.pasteBuf + s;
+      const end = buf.indexOf(PASTE_END);
+      if (end === -1) { st.pasteBuf = buf; s = ''; break; }
+      events.push({ type: 'paste', text: buf.slice(0, end) });
+      st = { inPaste: false, pasteBuf: '', partial: '' };
+      s = buf.slice(end + PASTE_END.length);
+      continue;
+    }
+    if (s.startsWith(PASTE_START)) { st = { inPaste: true, pasteBuf: '', partial: '' }; s = s.slice(PASTE_START.length); continue; }
+    // a half-received start marker (ESC [ 2 0 ...): hold it for the next chunk, never read it as Esc + text
+    if (s.length >= 2 && s.length < PASTE_START.length && PASTE_START.startsWith(s)) { st.partial = s; s = ''; break; }
+    if (s === '\x1b') { events.push({ type: 'key', name: 'escape' }); s = ''; continue; }
+    if (s[0] === '\x1b') {
+      // Focus reporting (CSI ?1004h, enabled by sound/index.js): CSI I = focus in, CSI O = focus out.
+      if (s.startsWith('\x1b[I') || s.startsWith('\x1b[O')) { events.push({ type: 'focus', focused: s[2] === 'I' }); s = s.slice(3); continue; }
+      // QUOXON-MOUSE: SGR mouse reports; a report split across chunks is held, never typed into the composer.
+      const mm = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(s);
+      if (mm) { events.push(mouseEvent(Number(mm[1]), Number(mm[2]), Number(mm[3]), mm[4])); s = s.slice(mm[0].length); continue; }
+      if (/^\x1b\[<[\d;]*$/.test(s)) { st.partial = s; s = ''; break; }
+      const cr = /^\x1b\[(\d+);(\d+)R/.exec(s);
+      if (cr) { events.push({ type: 'cursor', row: Number(cr[1]), col: Number(cr[2]) }); s = s.slice(cr[0].length); continue; }
+      const hit = CSI_LIST.find(k => s.startsWith(k));
+      if (hit) { events.push({ type: 'key', name: CSI_KEYS[hit] }); s = s.slice(hit.length); continue; }
+      // Unknown escape sequence: swallow ESC [ ... final byte, or a bare ESC+char (alt-x).
+      const m = /^\x1b\[[0-9;?]*[ -/]*[@-~]/.exec(s) || /^\x1bO./.exec(s);
+      if (m) { s = s.slice(m[0].length); continue; }
+      if (s.length >= 2) { events.push({ type: 'key', name: 'escape' }); s = s.slice(1); continue; }
+    }
+    // Plain run: printable text up to the next control char.
+    // Burst heuristic: text plus newlines delivered in ONE chunk, with content after
+    // the first newline, is a paste (terminal without bracketed paste), not typing.
+    const run = /^[^\x00-\x1f\x7f]+/.exec(s);
+    if (run) { events.push({ type: 'text', text: run[0] }); s = s.slice(run[0].length); continue; }
+    const c = s[0];
+    if (CTRL[c]) { events.push({ type: 'key', name: CTRL[c] }); }
+    s = s.slice(1);
+  }
+  return { events: coalesceBurst(events, draft), state: st };
+}
+
+/**
+ * If a chunk produced text and then an Enter/newline FOLLOWED by more text, it is
+ * a non-bracketed paste: fold it into one paste event. A trailing single Enter
+ * (text then Enter at the end) stays as text + enter so fast typing still submits.
+ *
+ * Except a burst whose every line is a slash command (R3 D3): that is typed input batched by tmux,
+ * SSH/mosh or a script ("/help" Enter "/model x" Enter), never a paste, so each Enter runs its line.
+ * Folding it made a multi-line "/" draft that trapped every later Enter.
+ */
+const isEnter = (e) => e.type === 'key' && (e.name === 'enter' || e.name === 'newline');
+function commandLines(events, draft = '') {
+  let line = draft.includes('\n') ? '\n' : draft; // a multi-line draft is never a command line
+  for (const e of events) {
+    if (e.type === 'text') line += e.text;
+    else if (e.name === 'enter') { if (!line.startsWith('/')) return false; line = ''; }
+    else return false; // newline (Ctrl+J), tab or any other key: not plain typed commands
+  }
+  return line === '' || line.startsWith('/');
+}
+function coalesceBurst(events, draft = '') {
+  const hasInner = events.some((e, i) =>
+    isEnter(e) && i > 0 && i < events.length - 1 &&
+    events.slice(i + 1).some(x => x.type === 'text'));
+  if (!hasInner) return events;
+  if (commandLines(events, draft)) return events;
+  let text = '';
+  const rest = [];
+  for (let i = 0; i < events.length; i++) {
+    const e = events[i];
+    if (e.type === 'text') text += e.text;
+    else if (e.type === 'key' && (e.name === 'enter' || e.name === 'newline')) {
+      // a trailing Enter after the burst is a submit, not part of the paste
+      if (i === events.length - 1) rest.push(e); else text += '\n';
+    } else if (e.type === 'key' && e.name === 'tab') text += '\t';
+    else rest.push(e);
+  }
+  return [{ type: 'paste', text }, ...rest];
+}

package/lib/quoxon/launcher.js

@@ -0,0 +1,103 @@
+/**
+ * QUOXON-RESTART-LEAK: the conversation client's top-level launcher.
+ *
+ * Before this, /restart (and /update, /restart auto, a profile switch that restarts) ran the successor with
+ * spawnSync from INSIDE the old client and waited for it. The old client froze but stayed resident with its
+ * whole heap, so every restart nested one more TUI under the last: the owner's terminal reached 98 nested
+ * clients and 15 GB RSS (on the dev box, 2026-10-17).
+ *
+ * Now the first interactive `quox` on a terminal becomes this launcher: no React, no Ink, no api, no timers,
+ * never touches stdin. It runs the client as its child and waits. A client that wants a restart writes a
+ * handoff file (what to run, the one-shot env it carries) and exits with RESTART_EXIT_CODE; the launcher
+ * reads it, deletes it, and runs the successor. Any other exit is passed straight through. So after any
+ * number of restarts there is exactly one client process per terminal (plus this launcher).
+ *
+ * Tiny on purpose: it must import nothing heavy (bin/quox.js loads it before React, Ink or any command).
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir, constants as osConstants } from 'node:os';
+import { join } from 'node:path';
+
+/** The client asks its launcher for a restart with this exit code AND a handoff file (both, never one alone). */
+export const RESTART_EXIT_CODE = 75;
+/** Env var naming the handoff file. Read and DELETED by the client at startup, so nothing it spawns inherits it. */
+export const LAUNCHER_HANDOFF_ENV = 'QUOX_LAUNCHER_HANDOFF';
+/** QUOX_NO_LAUNCHER=1 turns the launcher off (the client then restarts the old, nested way). */
+export const NO_LAUNCHER_ENV = 'QUOX_NO_LAUNCHER';
+
+const ONE_SHOT = /^QUOX_RESTART_/; // carried into ONE successor only, never re-applied by the launcher
+
+let handoff; // undefined = not read yet; null = not launched; { path, base } = launched
+/**
+ * Client side, once at startup: am I running under a launcher? Reads and deletes the env var (a shell or
+ * `quox` the client spawns must never think it is the launched client). -> { path, base } | null.
+ */
+export function takeLauncherHandoff(env = process.env) {
+  if (env === process.env && handoff !== undefined) return handoff;
+  const path = env[LAUNCHER_HANDOFF_ENV] || null;
+  delete env[LAUNCHER_HANDOFF_ENV];
+  const r = path ? { path, base: { ...env } } : null; // base: the env as launched, to send only what a restart changes
+  if (env === process.env) handoff = r;
+  return r;
+}
+/** Test hook: forget the cached handoff. */
+export function resetLauncherHandoff() { handoff = undefined; }
+
+/** Should this invocation become the launcher? Only an interactive client on a real terminal, never a launched child. */
+export function shouldLaunch({ argv = [], env = process.env, isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
+  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1') return false;
+  const head = argv.indexOf('--') === -1 ? argv : argv.slice(0, argv.indexOf('--'));
+  return !head.some(a => a === '--print' || a.startsWith('--print=') || a === '-h' || a === '--help');
+}
+
+/**
+ * Client side: hand a restart to the launcher. `plan` is { cmd, args, env } (restartPlan in slash/restart.js);
+ * only the env entries that differ from the launched env are written (the launcher adds them to its own).
+ * -> true when the handoff file was written (the caller then exits with RESTART_EXIT_CODE).
+ */
+export function writeRestartHandoff(h, plan, { write = writeFileSync } = {}) {
+  if (!h?.path || !plan?.cmd) return false;
+  const env = {};
+  for (const [k, v] of Object.entries(plan.env || {})) if (v !== undefined && (ONE_SHOT.test(k) || h.base[k] !== v)) env[k] = v; // a one-shot always rides: the launcher strips them between runs
+  try { write(h.path, JSON.stringify({ cmd: plan.cmd, args: plan.args || [], env }), { mode: 0o600 }); return true; }
+  catch { return false; }
+}
+
+/**
+ * Launcher side: run the client, and again each time it asks for a restart. Resolves with the exit code to
+ * leave with. `deps` lets tests stand in for spawn and the handoff directory.
+ */
+export async function runLauncher({ argv = [], execPath = process.execPath, script = process.argv[1], env = process.env, deps = {}, onSpawn = null } = {}) {
+  const d = { spawn, mkdtemp: () => mkdtempSync(join(tmpdir(), 'quox-launch-')), read: (p) => readFileSync(p, 'utf8'), rm: (p) => rmSync(p, { force: true, recursive: true }), signals: process, ...deps };
+  let dir;
+  try { dir = d.mkdtemp(); } catch { return null; } // no handoff dir: the caller runs the client in-process (old behaviour)
+  const file = join(dir, 'restart.json');
+  const carry = (e) => Object.fromEntries(Object.entries(e).filter(([k]) => !ONE_SHOT.test(k) && k !== LAUNCHER_HANDOFF_ENV)); // later runs never re-apply a one-shot
+  let child = null;
+  const forward = (sig) => () => { try { child?.kill(sig); } catch { /* gone */ } };
+  const handlers = { SIGINT: () => {}, SIGQUIT: () => {}, SIGTERM: forward('SIGTERM'), SIGHUP: forward('SIGHUP') }; // ^C belongs to the client (same process group)
+  for (const [s, f] of Object.entries(handlers)) d.signals.on(s, f);
+  let next = { cmd: execPath, args: [script, ...argv], env: { ...env } }; // the first run keeps any one-shot it was started with
+  try {
+    for (;;) {
+      d.rm(file);
+      const r = await new Promise((done) => {
+        try { child = d.spawn(next.cmd, next.args, { stdio: 'inherit', env: { ...next.env, [LAUNCHER_HANDOFF_ENV]: file } }); }
+        catch (e) { done({ error: e }); return; }
+        onSpawn?.(child);
+        child.once('error', (e) => done({ error: e }));
+        child.once('exit', (code, signal) => done({ code, signal }));
+      });
+      child = null;
+      if (r.error) { process.stderr.write(`quox: could not start ${next.cmd} (${r.error.code || r.error.message})\n`); return 1; }
+      let ask = null;
+      if (r.code === RESTART_EXIT_CODE) { try { ask = JSON.parse(d.read(file)); } catch { ask = null; } }
+      if (!ask?.cmd) return r.signal ? 128 + (osConstants.signals[r.signal] || 0) : (r.code ?? 1);
+      next = { cmd: ask.cmd, args: Array.isArray(ask.args) ? ask.args : [], env: { ...carry(next.env), ...(ask.env || {}) } }; // the env the client was launched with, plus what its restart changed
+    }
+  } finally {
+    for (const [s, f] of Object.entries(handlers)) d.signals.off(s, f);
+    d.rm(dir);
+  }
+}