quoxcli 0.2.0 → 0.3.1

package/lib/quoxon/slash/picker.js

@@ -1,6 +1,8 @@
 /**
  * A modal list under the composer (the /resume picker, the /config card). While open it takes every key,
  * like the /connect card: Up/Down select, Enter picks, Esc closes, Left/Right/Space go to onAdjust.
+ * Typing (any text but a Space the card uses) closes it and goes to the composer, so a slash command typed
+ * while it is open runs instead of being read as navigation (R3 D2). onEvent returns false for those keys.
  */
 export function createPicker({ refresh = () => {} } = {}) {
   let cur = null; // { title, rows, sel, hint, onPick, onAdjust, onClose, rowsFn }
@@ -13,7 +15,20 @@ export function createPicker({ refresh = () => {} } = {}) {
     onEvent(e) {
       if (!cur) return false;
       const rows = cur.rowsFn ? cur.rowsFn() : cur.rows;
-      if (e.type !== 'key' && !(e.type === 'text' && e.text === ' ')) return true; // typing is swallowed while open
+      // onChar(char, sel): a card key such as f or d. true, or a new selection index = handled.
+      if (e.type === 'text' && cur.onChar) {
+        const r = cur.onChar(e.text, cur.sel);
+        if (r === true || typeof r === 'number') {
+          if (typeof r === 'number') {
+            const n = (cur.rowsFn ? cur.rowsFn() : cur.rows).length;
+            cur.sel = Math.max(0, Math.min(r, Math.max(0, n - 1)));
+          }
+          refresh();
+          return true;
+        }
+      }
+      if (e.type === 'paste' || (e.type === 'text' && !(e.text === ' ' && cur.onAdjust))) { close(); return false; } // typing goes to the composer
+      if (e.type !== 'key' && !(e.type === 'text' && e.text === ' ')) return true;
       const name = e.type === 'text' ? 'space' : e.name;
       if (name === 'escape' || name === 'ctrl-c') { close(); return true; }
       if (name === 'up' && rows.length) cur.sel = (cur.sel - 1 + rows.length) % rows.length;
@@ -32,7 +47,10 @@ export function createPicker({ refresh = () => {} } = {}) {
       const rows = cur.rowsFn ? cur.rowsFn() : cur.rows;
       const max = 10;
       const start = Math.max(0, Math.min(cur.sel - max + 1, rows.length - max));
-      return { title: cur.title, rows: rows.slice(start, start + max), sel: cur.sel - start, more: Math.max(0, rows.length - max), hint: cur.hint, empty: cur.empty };
+      const title = cur.titleFn ? cur.titleFn() : cur.title;
+      const more = Math.max(0, rows.length - max);
+      const view = rows.slice(start, start + max);
+      return { title, rows: view, sel: cur.sel - start, more, hint: cur.hint, empty: cur.empty };
     }
   };
 }

package/lib/quoxon/slash/restart.js

@@ -65,14 +65,42 @@ export function newerBuild({ startSha, runningRoot = RUNNING_ROOT, env = process
   return DIFFERENT_NOTICE; // unrelated or unknown history: say so, never claim "newer
 }
 
-/** Poll at most every `everyMs`; calls onNotice once. -> stop(). */
-export function startBuildWatch({ onNotice, everyMs = 60000, check = newerBuild, ...opts } = {}) {
-  let said = false;
+/** The installed build's id (its CLI tree's git HEAD), read locally. null when it cannot be told. */
+export function installedBuildId({ runningRoot = RUNNING_ROOT, env = process.env } = {}) {
+  return headOf(cliRootOf(findOnPath('quox', env)) || runningRoot);
+}
+
+/**
+ * Poll at most every `everyMs`; calls onNotice(text, buildId) once. -> stop().
+ * With `repeat`, keeps watching and calls onNotice again for each LATER installed build (a new id).
+ */
+// settleMs defaults to 0 here (announce at once); the TUI (main.js) passes settleMsFrom() so real sessions settle.
+export const RESTART_SETTLE_MS = 120000; // a newer build must stay the installed one this long before it is announced
+export const RESTART_BOOT_WINDOW_MS = 5 * 60 * 1000; // after a start, the settle window runs from the start
+
+export function settleMsFrom(env = process.env) {
+  const n = Number(env.QUOX_RESTART_SETTLE_MS);
+  return env.QUOX_RESTART_SETTLE_MS != null && env.QUOX_RESTART_SETTLE_MS !== '' && Number.isFinite(n) && n >= 0 ? n : RESTART_SETTLE_MS;
+}
+
+export function startBuildWatch({ onNotice, everyMs = 60000, check = newerBuild, repeat = false, buildId = installedBuildId, settleMs = 0, now = Date.now, ...opts } = {}) {
+  let last; // repeat mode: the last build announced
+  let seen; let seenAt = 0; let seenNotice = null; // repeat mode: the build waiting to settle, and when it last changed
+  const bootAt = now();
   const id = setInterval(() => {
-    if (said) return;
     let t = null;
     try { t = check(opts); } catch { t = null; }
-    if (t) { said = true; onNotice(t); clearInterval(id); }
+    if (!t) return;
+    let b = null;
+    try { b = buildId(opts); } catch { b = null; }
+    if (!repeat) { clearInterval(id); onNotice(t, b); return; }
+    if (b === last && last !== undefined) return;
+    if (b !== seen || seen === undefined) { seen = b; seenAt = now(); } // a new build resets the settle timer
+    seenNotice = t;
+    const t0 = now() - bootAt < RESTART_BOOT_WINDOW_MS ? Math.max(seenAt, bootAt) : seenAt;
+    if (now() - t0 < settleMs) return;
+    last = b;
+    onNotice(seenNotice, b);
   }, everyMs);
   id.unref?.();
   return () => clearInterval(id);
@@ -84,15 +112,18 @@ export function startBuildWatch({ onNotice, everyMs = 60000, check = newerBuild,
  */
 export function restartArgs(argv = [], conversationId = null, { profile = null, name = null } = {}) {
   const out = [];
+  const pin = Boolean(profile) && !argv.includes('--demo'); // the profile the session RESOLVED wins over whatever argv said
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
+    if (pin && (a === '-p' || a === '--profile')) { const n = argv[i + 1]; if (n !== undefined && !n.startsWith('-')) i++; continue; }
+    if (pin && a.startsWith('--profile=')) continue;
     if (a === '--conversation') { i++; continue; }
     if (a === '--resume') { const n = argv[i + 1]; if (n !== undefined && !n.startsWith('-')) i++; continue; }
     if (/^--(resume|conversation)=/.test(a)) continue;
     out.push(a);
   }
   const has = (...f) => out.some(a => f.includes(a) || f.some(x => a.startsWith(`${x}=`)));
-  if (profile && !has('-p', '--profile') && !out.includes('--demo')) out.push('-p', profile);
+  if (pin) out.push('-p', profile);
   if (name && !has('-n', '--name')) out.push('-n', name);
   return conversationId ? [...out, '--resume', conversationId] : out;
 }
@@ -121,8 +152,19 @@ export function checkRestart({ env = process.env, bin = findOnPath('quox', env),
   });
 }
 
+/** Env var carrying the held slot name from the old client to its restarted successor. */
+export const RESTART_SLOT_ENV = 'QUOX_RESTART_SLOT';
+/** Env var carrying the /attach target (`agent:<id>` or `slot:<name>`) to the restarted successor. */
+export const RESTART_ATTACH_ENV = 'QUOX_RESTART_ATTACH';
+/** Env var carrying one line for the restarted client to say first (a failed /update says why there). */
+export const RESTART_NOTE_ENV = 'QUOX_RESTART_NOTE';
+/** Env var carrying the window's own org (#1034: /org switch is window-scoped) to the restarted successor. */
+export const RESTART_ORG_ENV = 'QUOX_RESTART_ORG';
+/** Env var carrying the window's /mode (PLAN MODE: only 'plan' is carried; ask is the default) to the restarted successor. */
+export const RESTART_MODE_ENV = 'QUOX_RESTART_MODE';
+
 /** Terminal modes the client turns on (bracketed paste, focus reporting, hidden cursor): all off before the hand-over. */
-export const TERMINAL_RESTORE = '\x1b[?2004l\x1b[?1004l\x1b[?25h';
+export const TERMINAL_RESTORE = '\x1b[?2004l\x1b[?1004l\x1b[?25h\x1b[?1006l\x1b[?1002l\x1b[?1000l'; // bracketed paste, focus, cursor; mouse tracking off (QUOXON-MOUSE)
 
 /** Give the terminal back in a plain state: cooked mode, stdin paused, modes off. */
 export function restoreTerminal({ stdin = process.stdin, stdout = process.stdout } = {}) {
@@ -130,15 +172,31 @@ export function restoreTerminal({ stdin = process.stdin, stdout = process.stdout
   try { if (stdout?.isTTY) stdout.write(TERMINAL_RESTORE); } catch { /* closed */ }
 }
 
+/**
+ * What a restart runs: { cmd, args, env }. The installed quox (or this tree), the same arguments with --resume
+ * for this conversation, and the one-shot hand-over env (held slot, attach, org, plan mode) for the successor.
+ */
+export function restartPlan({ argv, conversationId, profile = null, name = null, slot = null, attach = null, org = null, mode = null, env = process.env, bin = findOnPath('quox', env) }) {
+  const args = restartArgs(argv, conversationId, { profile, name });
+  let childEnv = profile && !argv.includes('--demo') ? { ...env, QUOX_PROFILE: profile } : env; // belt and braces: same profile even if -p were lost
+  if (slot) childEnv = { ...childEnv, [RESTART_SLOT_ENV]: slot }; // the held slot rides along; the new client takes it over before this one is gone
+  if (attach) childEnv = { ...childEnv, [RESTART_ATTACH_ENV]: attach }; // so does the attached agent or slot
+  if (org) childEnv = { ...childEnv, [RESTART_ORG_ENV]: org }; // and the window's org (never the profile's file)
+  if (mode === 'plan') childEnv = { ...childEnv, [RESTART_MODE_ENV]: 'plan' }; // and the window's /mode (never the profile)
+  const [cmd, lead] = restartTarget(env, bin);
+  return { cmd, args: [...lead, ...args], env: childEnv };
+}
+
 /**
  * Run the installed quox in this terminal, wait for it, and hand back { code } (its exit code), or
  * { error } when it could not be started (the caller stays in the current client and says so).
+ * Only used when there is no launcher (QUOX_NO_LAUNCHER=1, or no handoff dir): it NESTS the successor under
+ * this process, which stays resident until the successor exits. The launcher path (launcher.js) does not.
  */
-export function execRestart({ argv, conversationId, profile = null, name = null, env = process.env, spawn = spawnSync, bin = findOnPath('quox', env), restore = restoreTerminal }) {
-  const args = restartArgs(argv, conversationId, { profile, name });
+export function execRestart({ argv, conversationId, profile = null, name = null, slot = null, attach = null, org = null, mode = null, env = process.env, spawn = spawnSync, bin = findOnPath('quox', env), restore = restoreTerminal }) {
+  const plan = restartPlan({ argv, conversationId, profile, name, slot, attach, org, mode, env, bin });
   restore(); // the child owns the terminal now
-  const [cmd, lead] = restartTarget(env, bin);
-  const r = spawn(cmd, [...lead, ...args], { stdio: 'inherit', env });
-  if (r.error) return { error: `${r.error.code || 'failed'}: ${r.error.message}`, bin: cmd };
-  return { code: r.status ?? (r.signal ? 128 + (os.constants.signals[r.signal] || 0) : 1), bin: cmd };
+  const r = spawn(plan.cmd, plan.args, { stdio: 'inherit', env: plan.env });
+  if (r.error) return { error: `${r.error.code || 'failed'}: ${r.error.message}`, bin: plan.cmd };
+  return { code: r.status ?? (r.signal ? 128 + (os.constants.signals[r.signal] || 0) : 1), bin: plan.cmd };
 }

package/lib/quoxon/slash/rowCmd.js

@@ -0,0 +1,157 @@
+/**
+ * QUOXON-FW17: /row, custom rows above the status line. Kept out of app.js.
+ *
+ * url rows save to the user's server-side preferences (api.setRowPrefs, namespace quoxonRows); cmd rows save to a
+ * local file only (api.setLocalCmdRows) and are never sent anywhere. The engine (rows.js) does the polling.
+ */
+import { checkRow, parseRowCmd, splitRows, rowLabel, normRows, MAX_ROWS, rowDisplay, ROLES, secretInRow, syncable } from '../rows.js';
+import { clip } from '../theme.js';
+import { createRowWalk } from './rowWalk.js';
+
+/** How a row reads its data, in words (for /row list). */
+export const whereOf = (r) => {
+  const s = r.source;
+  if (s.type === 'url') return `url ${s.url}`;
+  if (s.type === 'quox') return `quox ${s.path}${s.service === 'collector' ? ' (collector)' : ''}`;
+  if (s.type === 'plugin') return `plugin ${s.plugin} ${s.path}`;
+  return `cmd ${s.cmd}  (this machine only)`;
+};
+
+/** ROWS: rows changed elsewhere (`quox rows`, another window) reach an open window within this long. */
+export const RELOAD_MS = 60 * 1000;
+
+const cleanLine = (l) => String(l).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '');
+
+export function createRowCmd({ api, say, engine, bump, cols, setT = setTimeout, clearT = clearTimeout }) {
+  let url = []; // synced (url, quox and plugin rows)
+  let cmd = []; // this machine only
+  let reloadTimer = null;
+  const all = () => [...url, ...cmd];
+  const apply = () => { engine.setRows(all()); bump(); };
+
+  /** Start up: the cached/local rows at once, then the server copy. Never throws. */
+  async function load() {
+    try { url = api.localRowPrefs?.() || []; cmd = api.localCmdRows?.() || []; } catch { url = []; cmd = []; }
+    engine.setEnabled(api.settings?.().rows !== 'off');
+    apply();
+    await refreshFromStores();
+    schedule();
+  }
+
+  /** Re-read both stores; the engine keeps the state of rows that did not change. -> true when anything changed. */
+  async function refreshFromStores() {
+    const before = JSON.stringify(all());
+    try { cmd = api.localCmdRows?.() || cmd; } catch { /* keep */ }
+    try {
+      const r = await api.rowPrefs?.();
+      if (r?.source === 'server') url = normRows(r.rows);
+    } catch { /* the local copy stands */ }
+    const changed = JSON.stringify(all()) !== before;
+    if (changed) apply();
+    return changed;
+  }
+
+  function schedule() {
+    clearT(reloadTimer);
+    reloadTimer = setT(async () => { await refreshFromStores(); schedule(); }, RELOAD_MS);
+    reloadTimer?.unref?.();
+  }
+
+  /** Save one row (new, or replacing `replace`). Shared by /row add and the walk. -> { ok, text }. */
+  async function put(row, { replace = null } = {}) {
+    const exists = replace || find(row.id);
+    if (!exists && all().length >= MAX_ROWS) return { ok: false, text: `You have ${MAX_ROWS} rows already (the most there is room for). /row rm <id> makes space.` };
+    if (exists) { url = url.filter((x) => x !== exists); cmd = cmd.filter((x) => x !== exists); }
+    if (exists && !syncable(exists) && syncable(row)) api.setLocalCmdRows?.(cmd);
+    if (syncable(row)) {
+      url = [...url, row];
+      apply();
+      const r = api.setRowPrefs ? await api.setRowPrefs(url) : { synced: true };
+      if (!r.synced) return { ok: false, text: `Saved on this machine only (${r.error || 'the server did not take it'}). Making the change again retries.` };
+      return { ok: true, text: `Row ${row.id} ${exists ? 'saved' : 'added'}. It follows your account to other machines. /row test ${row.id} shows the raw value.` };
+    }
+    cmd = [...cmd, row];
+    apply();
+    if (exists && syncable(exists) && api.setRowPrefs) await api.setRowPrefs(url);
+    const ok = api.setLocalCmdRows ? api.setLocalCmdRows(cmd) : true;
+    return ok ? { ok: true, text: `Row ${row.id} ${exists ? 'saved' : 'added'}. It runs your command on THIS machine only and is never synced.` } : { ok: false, text: 'Could not save the row to the local file; it lasts until you quit.' };
+  }
+
+  const walk = createRowWalk({ say, bump, probe: (row) => engine.probe(row), save: put, existing: () => all() });
+
+  async function saveUrl(tail = '') {
+    if (!api.setRowPrefs) return;
+    const r = await api.setRowPrefs(url);
+    if (!r.synced) say(`Saved on this machine only (${r.error || 'the server did not take it'}). Making the change again retries.`, 'warn');
+    else if (tail) say(tail);
+  }
+
+  const find = (id) => all().find((r) => r.id.toLowerCase() === String(id).toLowerCase());
+
+  async function handle(arg) {
+    const sub = parseRowCmd(arg);
+    const w = Math.max(20, cols() - 4);
+    switch (sub.kind) {
+      case 'error': return say(sub.text, 'warn');
+      case 'list': {
+        const rows = all();
+        if (!rows.length) return say('No custom rows yet. /row new walks you through one (or quox rows add from a shell).');
+        say(`Custom rows (${rows.length} of ${MAX_ROWS})${engine.isEnabled() ? '' : ', hidden: /row on shows them'}:`);
+        for (const r of rows) {
+          const s = engine.state(r.id);
+          say(clip(`  ${r.id}${r.label && r.label !== r.id ? ` (${r.label})` : ''}  every ${r.source.every}  ${whereOf(r)}${r.template ? '' : '  [status-row contract]'}`, w));
+          if (s && engine.isEnabled()) say(clip(`      now: ${rowDisplay(s).text}`, w), s.status === 'error' ? 'warn' : undefined);
+        }
+        return undefined;
+      }
+      case 'on': case 'off': {
+        engine.setEnabled(sub.kind === 'on');
+        api.saveSetting?.('rows', sub.kind);
+        bump();
+        return say(sub.kind === 'on' ? 'Custom rows are on.' : 'Custom rows hidden and paused. /row on brings them back.');
+      }
+      case 'rm': {
+        const r = find(sub.id);
+        if (!r) return say(`No row "${sub.id}". /row list shows them.`, 'warn');
+        if (syncable(r)) { url = url.filter((x) => x !== r); apply(); await saveUrl(); } else { cmd = cmd.filter((x) => x !== r); apply(); api.setLocalCmdRows?.(cmd); }
+        return say(`Removed row ${r.id}.`, 'ok');
+      }
+      case 'test': {
+        const r = find(sub.id);
+        if (!r) return say(`No row "${sub.id}". /row list shows them.`, 'warn');
+        say(`Testing ${r.id}…`);
+        const p = await engine.probe(r);
+        if (!p.ok && !p.raw) return say(clip(`⚠ ${rowLabel(r)}: ${p.error}`, w), 'warn');
+        const lines = p.raw.split('\n').filter((l) => l.trim()).slice(0, 4);
+        say('Raw value:');
+        for (const l of lines) say(clip(`  ${cleanLine(l)}`, w));
+        if (p.raw.length > 400 || lines.length >= 4) say('  …');
+        if (!p.ok) return say(clip(`⚠ ${rowLabel(r)}: ${p.error}`, w), 'warn');
+        for (const wn of p.warnings || []) say(clip(`Note: ${wn}`, w), 'warn');
+        if (p.seg?.link) say(clip(`Link: ${p.seg.link}`, w));
+        return say(clip(`Row shows: ${p.text}`, w), 'ok');
+      }
+      case 'add': {
+        const v = checkRow(sub.row);
+        if (v.error) return say(v.error, 'warn');
+        const secret = secretInRow(v.row);
+        if (secret) return say(secret, 'warn');
+        const r = await put(v.row);
+        return say(r.text, r.ok ? 'ok' : 'warn');
+      }
+      case 'new': return walk.start('new');
+      case 'edit': return walk.start('edit', sub.id);
+      case 'reload': {
+        const changed = await refreshFromStores();
+        return say(changed ? `Rows reloaded: ${all().map((r) => r.id).join(', ') || 'none'}.` : 'Rows reloaded; nothing changed.');
+      }
+      default: return undefined;
+    }
+  }
+
+  return {
+    handle, load, stopEngine: () => { clearT(reloadTimer); engine.stop(); }, view: () => engine.view(), all, colours: ROLES, counts: () => splitRows(all()),
+    /** the /row new|edit walk: app.js routes typed lines, its y/N/c card and Esc here */
+    walk
+  };
+}

package/lib/quoxon/slash/rowWalk.js

@@ -0,0 +1,175 @@
+/**
+ * ROWS (owner 2026-10-17): /row new and /row edit <id> in the quox window. The same shape as the hat walk
+ * (hatWalk.js): every question is a y/N/c card (askText) or a one-line text capture. Esc, or any slash command,
+ * ends the walk and nothing is saved. Before the last card the row is fetched ONCE and the card shows what it
+ * will say, so a row is never saved blind.
+ *
+ * Command rows get their own card naming the exact command, because a command runs a shell on this machine every
+ * refresh. This file has no I/O beyond the functions it is given (probe, save, existing).
+ */
+import { askText } from '../ask.js';
+import { checkRow, secretInRow, validId, parseEvery, rowLabel } from '../rows.js';
+
+export const KINDS = [
+  { key: 'url', name: 'a web address (URL) that returns JSON or text', ask: 'Which URL? It is fetched with no credentials.' },
+  { key: 'quox', name: 'a path on your own Quox, read with your session', ask: 'Which path? It starts with /api/; {org} is filled in for you. Example: /api/orgs/{org}/inbox/stats' },
+  { key: 'plugin', name: 'a status row a plugin ships', ask: 'Which plugin and row path? Example: qpe row' },
+  { key: 'cmd', name: 'a command on THIS machine (never synced or shared)', ask: 'Which command? It runs through your shell, 5 s at most.' }
+];
+
+const slug = (s) => String(s ?? '').toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24);
+
+/** A kind and the typed target -> a source, or { error }. */
+export function sourceFrom(kind, line, every = '60s') {
+  const t = String(line ?? '').trim();
+  if (!t) return { error: 'That is empty.' };
+  if (kind === 'url') return { source: { type: 'url', url: t, every } };
+  if (kind === 'cmd') return { source: { type: 'cmd', cmd: t, every } };
+  if (kind === 'quox') return { source: { type: 'quox', service: t.startsWith('/api/v1/') ? 'collector' : 'auth', path: t, every } };
+  const [plugin, ...rest] = t.split(/\s+/);
+  if (!rest.length) return { error: 'Give the plugin id and the row path, e.g. qpe row.' };
+  return { source: { type: 'plugin', plugin, path: rest.join(''), every } };
+}
+
+/** "1", "url", "a URL" -> a KINDS key, or null. */
+export function pickKind(line) {
+  const t = String(line ?? '').trim().toLowerCase();
+  if (/^[1-4]$/.test(t)) return KINDS[Number(t) - 1].key;
+  const hit = KINDS.find((k) => k.key === t || (t.length >= 3 && k.name.toLowerCase().includes(t)));
+  return hit ? hit.key : (t === 'command' || t === 'shell' ? 'cmd' : null);
+}
+
+export function createRowWalk({ say, bump = () => {}, probe, save, existing }) {
+  let W = null;
+
+  const ask = (question, reason = '') => { const st = { at: Date.now() }; W.card = st; say(askText(question, { reason }), 'ask'); return st; };
+  const yn = (question, on, reason) => { W.wait = { kind: 'yn', on }; ask(question, reason); bump(); };
+  // path: the answer may itself start with / (a quox path like /api/...), so only a known slash command ends the walk
+  const text = (prompt, on, { empty = false, path = false } = {}) => { W.wait = { kind: 'text', on, empty, path }; W.card = null; say(prompt); bump(); };
+  const end = () => { W = null; bump(); };
+
+  /** Validate, preview once, then the final card. */
+  async function preview(draft, verb) {
+    const c = checkRow(draft);
+    if (c.error) { say(c.error, 'warn'); return W?.retry?.(); }
+    const secret = secretInRow(c.row);
+    if (secret) { say(secret, 'warn'); return W?.retry?.(); }
+    const row = c.row;
+    say(`Fetching ${rowLabel(row)} once to show you what it will say…`);
+    const p = await probe(row);
+    if (!W) return undefined; // cancelled while fetching
+    if (p.ok) {
+      say(`It will show: ${p.text}`, 'ok');
+      for (const w of p.warnings || []) say(`Note: ${w}`, 'warn');
+    } else say(`It could not be read just now (${p.error}). You can still save it; the row shows the problem until it works.`, 'warn');
+    yn(`${verb} the ${rowLabel(row)} row?`, async (yes) => {
+      if (!yes) { say('Nothing saved.'); return end(); }
+      const r = await save(row, { replace: W.replace || null });
+      say(r.text, r.ok ? 'ok' : 'warn');
+      end();
+    }, row.source.type === 'cmd' ? 'Runs on this machine only, never synced' : 'Follows your account to your other machines');
+    return undefined;
+  }
+
+  // Shared tail: template, interval, then preview.
+  function tail(draft, verb) {
+    const askTemplate = () => text(draft.template
+      ? `Template? Enter keeps ${draft.template}; "-" uses the status-row contract ({"text": ...}).`
+      : 'Template? Enter reads the status-row contract ({"text": ..., "value": ..., "tone": ...}) or plain text. Or type one, e.g. {{pending_approvals}} waiting', (line) => {
+      const t = line.trim();
+      if (t === '-') delete draft.template; else if (t) draft.template = t;
+      askEvery();
+    }, { empty: true });
+    const askEvery = () => yn(`Refresh every ${draft.source.every}?`, (yes) => {
+      if (yes) return preview(draft, verb);
+      const again = () => text('How often? 30s, 5m or 1h (5 s to 1 day).', (line) => {
+        if (parseEvery(line) === null) { say(`"${line.trim()}" is not an interval.`, 'warn'); return again(); }
+        draft.source.every = line.trim(); preview(draft, verb);
+      });
+      again();
+    });
+    W.retry = askTemplate;
+    askTemplate();
+  }
+
+  function askSource(draft, verb) {
+    KINDS.forEach((k, i) => say(`  ${i + 1}. ${k.name}`));
+    const pick = () => text('Where does it read from? A number.', (line) => {
+      const kind = pickKind(line);
+      if (!kind) { say('Pick 1, 2, 3 or 4.', 'warn'); return pick(); }
+      const target = () => text(KINDS.find((k) => k.key === kind).ask, (l2) => {
+        const s = sourceFrom(kind, l2, draft.source?.every || '60s');
+        if (s.error) { say(s.error, 'warn'); return target(); }
+        draft.source = s.source;
+        const c = checkRow({ ...draft, template: draft.template });
+        if (c.error && !/template|Template/.test(c.error)) { say(c.error, 'warn'); return target(); }
+        const secret = secretInRow(draft);
+        if (secret) { say(secret, 'warn'); return target(); }
+        if (kind === 'cmd') return yn(`Run \`${s.source.cmd}\` on this machine every ${s.source.every}?`, (yes) => {
+          if (!yes) { say('Nothing saved.'); return end(); }
+          tail(draft, verb);
+        }, 'A command row runs a shell here and is never synced or shared');
+        tail(draft, verb);
+      }, { path: kind === 'quox' });
+      target();
+    });
+    pick();
+  }
+
+  function startNew() {
+    W = { mode: 'new' };
+    const draft = { source: { every: '60s' } };
+    const askName = () => text('What should the row be called? A short label, e.g. Approvals.', (line) => {
+      const label = line.trim().slice(0, 24);
+      const id = slug(label);
+      if (!validId(id)) { say('Use letters or digits in the name.', 'warn'); return askName(); }
+      if (existing().some((r) => r.id.toLowerCase() === id)) { say(`A row called ${id} exists. /row edit ${id} changes it, or pick another name.`, 'warn'); return askName(); }
+      draft.id = id; draft.label = label;
+      askSource(draft, 'Add');
+    });
+    askName();
+  }
+
+  function startEdit(id) {
+    const cur = existing().find((r) => r.id.toLowerCase() === String(id).toLowerCase());
+    if (!cur) { say(`No row "${id}". /row list shows them.`, 'warn'); return; }
+    W = { mode: 'edit', replace: cur };
+    const draft = JSON.parse(JSON.stringify(cur));
+    yn(`Change where ${rowLabel(cur)} reads from?`, (yes) => {
+      if (yes) return askSource(draft, 'Save');
+      yn('Rename it?', (y2) => {
+        if (!y2) return tail(draft, 'Save');
+        const again = () => text('What is the new label?', (line) => { const l = line.trim().slice(0, 24); if (!l) { say('A label cannot be empty.', 'warn'); return again(); } draft.label = l; tail(draft, 'Save'); });
+        again();
+      });
+    });
+  }
+
+  return {
+    active: () => Boolean(W),
+    card: () => (W?.wait?.kind === 'yn' ? W.card : null),
+    start(kind, arg = '') {
+      if (W) { say('A row walk is already open. Esc cancels it.', 'warn'); return; }
+      if (kind === 'new') return startNew();
+      return startEdit(arg);
+    },
+    /** One typed line. true = consumed. A slash command ends the walk and is left to run. */
+    answer(line) {
+      if (!W?.wait) return false;
+      const t = String(line ?? '').trim();
+      const isPath = W.wait.kind === 'text' && W.wait.path && t.startsWith('/api/');
+      if (t.startsWith('/') && !isPath) { W = null; say('Row walk ended. Nothing was saved.'); bump(); return false; }
+      const w = W.wait;
+      if (w.kind === 'yn') {
+        const yes = /^y(es)?$/i.test(t);
+        if (!yes && t && !/^no?$/i.test(t)) return false; // c or free text: the card's normal chat behaviour
+        W.wait = null; Promise.resolve(w.on(yes)).catch((e) => { say(`Row walk failed: ${e?.message || 'error'}.`, 'warn'); end(); });
+        return true;
+      }
+      if (!t && !w.empty) return true;
+      W.wait = null; Promise.resolve(w.on(t)).catch((e) => { say(`Row walk failed: ${e?.message || 'error'}.`, 'warn'); end(); });
+      return true;
+    },
+    cancel() { if (!W) return false; W = null; say('Row walk cancelled. Nothing was saved.'); bump(); return true; }
+  };
+}

package/lib/quoxon/slash/settings.js

@@ -5,18 +5,24 @@
  * which case the shell wins and the card says so.
  */
 import { PROFILE_IDS } from '../sound/mapping.js';
+import { LEVELS, DEFAULT_LEVEL, normaliseLevel } from '../motion/level.js';
 
 // Captured at import, before anything here writes it: what the user's shell set.
-const SHELL = { theme: process.env.QUOX_THEME || null, motion: process.env.QUOX_REDUCED_MOTION || null };
+const SHELL = {
+  theme: process.env.QUOX_THEME || null,
+  motion: process.env.QUOX_REDUCED_MOTION === '1' ? 'quiet' : (normaliseLevel(process.env.QUOX_MOTION) || null),
+  motionVar: process.env.QUOX_REDUCED_MOTION === '1' ? 'QUOX_REDUCED_MOTION' : 'QUOX_MOTION',
+};
 
 
 /** The settings this build can honour. Sound is the /sound controller's own profile (server-side soundProfile). */
 export function settingsList({ sound = true } = {}) {
   return [
     { id: 'theme', label: 'Theme', values: ['auto', 'dark', 'light'], def: 'auto', help: 'auto follows your terminal background' },
-    { id: 'motion', label: 'Motion', values: ['full', 'reduced'], def: 'full', help: 'reduced stills the animations' },
+    { id: 'motion', label: 'Motion', values: LEVELS, def: DEFAULT_LEVEL, help: 'quiet stills it all; expressive adds glows; cinematic adds the dragon' },
     ...(sound ? [{ id: 'sound', label: 'Sound', values: PROFILE_IDS, def: 'minimal', help: 'same as /sound; saved to your account' }] : []),
     { id: 'verbose', label: 'Verbose', values: ['off', 'on', 'full'], def: 'on', help: 'protocol lines in turns' },
+    { id: 'slotBell', label: 'Slot bell', values: ['off', 'on'], def: 'on', help: 'a terminal bell when a slot message arrives' },
     { id: 'model', label: 'Model', action: 'model', help: 'Enter opens /model' }
   ];
 }
@@ -27,7 +33,9 @@ export function applySettings(s = {}, env = process.env, shell = SHELL) {
     if (s.theme === 'dark' || s.theme === 'light') env.QUOX_THEME = s.theme; else delete env.QUOX_THEME;
   }
   if (!shell.motion) {
-    if (s.motion === 'reduced') env.QUOX_REDUCED_MOTION = '1'; else delete env.QUOX_REDUCED_MOTION;
+    const level = normaliseLevel(s.motion) || DEFAULT_LEVEL; // pre-levels profiles saved full / reduced
+    if (level === DEFAULT_LEVEL) delete env.QUOX_MOTION; else env.QUOX_MOTION = level;
+    if (level === 'quiet') env.QUOX_REDUCED_MOTION = '1'; else delete env.QUOX_REDUCED_MOTION; // every older reader agrees
   }
   return { themeFromShell: Boolean(shell.theme), motionFromShell: Boolean(shell.motion) };
 }
@@ -38,13 +46,15 @@ export const shellOverrides = () => ({ ...SHELL });
 export function configRows(list, values, { shell = SHELL, model = 'auto' } = {}) {
   return list.map(it => {
     if (it.action === 'model') return { key: it.label, text: model, note: it.help };
-    const v = values[it.id] ?? it.def;
-    const forced = (it.id === 'theme' && shell.theme) ? `QUOX_THEME=${shell.theme} in your shell wins` : (it.id === 'motion' && shell.motion) ? 'QUOX_REDUCED_MOTION in your shell wins' : null;
+    const v = it.id === 'motion' ? (normaliseLevel(values.motion) || it.def) : (values[it.id] ?? it.def);
+    const motionVar = shell.motionVar || 'QUOX_MOTION';
+    const forced = (it.id === 'theme' && shell.theme) ? `QUOX_THEME=${shell.theme} in your shell wins`
+      : (it.id === 'motion' && shell.motion) ? (motionVar === 'QUOX_MOTION' ? `QUOX_MOTION=${shell.motion} in your shell wins` : `${motionVar} in your shell wins`) : null;
     return { key: it.label, text: it.values.map(x => (x === v ? `[${x}]` : x)).join('  '), note: forced || it.help };
   });
 }
 
 export const cycle = (it, cur, dir = 1) => {
-  const i = it.values.indexOf(cur ?? it.def);
+  const i = it.values.indexOf((it.id === 'motion' ? normaliseLevel(cur) : cur) ?? it.def);
   return it.values[(i + dir + it.values.length) % it.values.length];
 };