quoxcli 0.3.1 → 0.5.0

package/lib/core/governedSession.js

@@ -12,7 +12,18 @@ import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync as realSpawnSync } from 'node:child_process';
-import { qArt, colorOn } from './banner.js';
+import { colorOn } from './banner.js';
+import { qLines, qDims } from '../quoxon/qart.js';
+
+/**
+ * The session banner's Q is quoxon's settled vector horned-Q (the face of the app, same mark as
+ * bare `quox` and cli.quox.ai), not the old half-block bitmap. 'small' for a narrow terminal, 'mid'
+ * otherwise. Returns the art rows and their visible width (used to pad the text column alignment).
+ */
+function introArt(color, cols) {
+  const size = cols && cols < 72 ? 'small' : 'mid';
+  return { lines: qLines(size, { color }), width: qDims(size).cols };
+}
 import { startHeartbeat as realStartHeartbeat } from './sessionHeartbeat.js';
 
 const NAME_RE = /^[A-Za-z0-9._-]{1,48}$/;
@@ -37,8 +48,6 @@ export function autoName(now = new Date()) {
 export const PROGRAMS = {
   claude: { tag: '', bin: 'claude', resumeHint: (n) => `quox claude --resume ${n}` },
   codex: { tag: 'codex-', bin: 'codex', resumeHint: (n) => `quox codex resume ${n}` },
-  // gemini resumes by index or "latest" (--resume latest | --resume N), not by name.
-  gemini: { tag: 'gemini-', bin: 'gemini', resumeHint: () => 'quox gemini --resume latest' },
   tui: { tag: 'tui-', bin: 'quox', resumeHint: (n) => `quox tui --governed --name ${n}` },
 };
 
@@ -162,10 +171,10 @@ export function howItWorksLines({ name, program = 'claude', bare }) {
   ];
 }
 
-export function renderIntro({ name, host, mode, tmuxSession, note, program = 'claude', preattach }, { color = false } = {}) {
+export function renderIntro({ name, host, mode, tmuxSession, note, program = 'claude', preattach }, { color = false, cols = process.stdout?.columns } = {}) {
   const b = (s) => (color ? `\x1b[1m${s}\x1b[0m` : s);
   const d = (s) => (color ? `\x1b[2m${s}\x1b[0m` : s);
-  const art = qArt(color);
+  const { lines: art, width: artW } = introArt(color, cols);
   const modeText = {
     NEW: 'NEW',
     REATTACH: 'REATTACH (same process, no context reload)',
@@ -184,7 +193,7 @@ export function renderIntro({ name, host, mode, tmuxSession, note, program = 'cl
     b('How this works'),
     ...howItWorksLines({ name, program }).map(([k, v]) => `${d(k.padEnd(19))}${v}`),
   ];
-  const w = art[0] ? 14 : 0;
+  const w = art[0] ? artW : 0;
   const lines = [];
   for (let i = 0; i < Math.max(art.length, text.length); i++) {
     lines.push(`  ${art[i] || ' '.repeat(w)}   ${text[i] || ''}`);
@@ -256,7 +265,108 @@ export function ensureHelpBinding(d) {
   return r && r.status === 0 ? 'bound' : 'failed';
 }
 
-export function runGoverned({ program = 'claude', name, args = [], resume = false, noTmux = false, bin, preattach }, over) {
+/**
+ * SESSION-LAUNCH-DEDUPE: tmux session names are case-sensitive but conversation names are not, so
+ * `--resume quoxon` must find `quox-QUOXON`. Returns the real session name or null.
+ */
+export function findSessionCI(d, wanted) {
+  const r = d.spawnSync('tmux', ['list-sessions', '-F', '#{session_name}'], { encoding: 'utf8' });
+  if (!r || r.error || r.status !== 0) return null;
+  const w = String(wanted).toLowerCase();
+  const names = String(r.stdout || '').split('\n').map((l) => l.split('\t')[0].trim()).filter(Boolean);
+  return names.find((n) => n.toLowerCase() === w) || null;
+}
+
+const PS_RE = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/;
+const base = (t) => String(t || '').split('/').pop();
+
+/** True when argv is a claude process resuming `name` (case-insensitive), also via `node .../claude`. */
+export function resumesName(args, name) {
+  const t = String(args).trim().split(/\s+/);
+  let i = 0;
+  if (base(t[0]) === 'node' && base(t[1]) === 'claude') i = 1;
+  else if (base(t[0]) !== 'claude') return false;
+  const want = String(name).toLowerCase();
+  for (let k = i + 1; k < t.length; k++) {
+    if ((t[k] === '--resume' || t[k] === '-r') && String(t[k + 1] || '').toLowerCase() === want) return true;
+    if (t[k].startsWith('--resume=') && t[k].slice(9).toLowerCase() === want) return true;
+  }
+  return false;
+}
+
+/** Live claude processes already holding conversation `name`: [{ pid, tty, tmux }]. */
+export function findLiveHolders(d, name) {
+  const ps = d.spawnSync('ps', ['-eo', 'pid=,ppid=,tty=,args='], { encoding: 'utf8' });
+  if (!ps || ps.error || ps.status !== 0) return [];
+  const procs = new Map();
+  for (const line of String(ps.stdout || '').split('\n')) {
+    const m = PS_RE.exec(line);
+    if (m) procs.set(Number(m[1]), { pid: Number(m[1]), ppid: Number(m[2]), tty: m[3], args: m[4] });
+  }
+  const self = d.pid ?? process.pid;
+  const hits = [...procs.values()].filter((p) => p.pid !== self && p.pid !== process.ppid && resumesName(p.args, name));
+  if (!hits.length) return [];
+  const panes = new Map();
+  const lp = d.spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_pid} #{session_name}'], { encoding: 'utf8' });
+  if (lp && !lp.error && lp.status === 0) {
+    for (const l of String(lp.stdout || '').split('\n')) {
+      const m = /^(\d+)\s+(\S+)$/.exec(l.trim());
+      if (m) panes.set(Number(m[1]), m[2]);
+    }
+  }
+  return hits.map((p) => {
+    let tmux = null;
+    for (let pid = p.pid, hops = 0; pid > 1 && hops < 32 && !tmux; hops++) { tmux = panes.get(pid) || null; pid = procs.get(pid)?.ppid ?? (hops === 0 ? p.ppid : 0); }
+    return { pid: p.pid, tty: p.tty, tmux };
+  });
+}
+
+/** The conversation name a claude argv resumes (`--resume X`, `-r X`, `--resume=X`), or null. */
+function resumedName(args) {
+  const t = String(args).trim().split(/\s+/);
+  let i = 0;
+  if (base(t[0]) === 'node' && base(t[1]) === 'claude') i = 1;
+  else if (base(t[0]) !== 'claude') return null;
+  for (let k = i + 1; k < t.length; k++) {
+    if ((t[k] === '--resume' || t[k] === '-r') && t[k + 1]) return t[k + 1];
+    if (t[k].startsWith('--resume=') && t[k].length > 9) return t[k].slice(9);
+  }
+  return null;
+}
+
+const PS_AGE_RE = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\d+)\s+(.*)$/;
+
+/**
+ * Every live `claude --resume <name>` on this box (same argv detection as findLiveHolders):
+ * [{ name, pid, tty, tmux, ageSec }]. tmux is the enclosing tmux session or null. [] if ps fails.
+ */
+export function listLiveSessions(d) {
+  const ps = d.spawnSync('ps', ['-eo', 'pid=,ppid=,tty=,etimes=,args='], { encoding: 'utf8' });
+  if (!ps || ps.error || ps.status !== 0) return [];
+  const procs = new Map();
+  for (const line of String(ps.stdout || '').split('\n')) {
+    const m = PS_AGE_RE.exec(line);
+    if (m) procs.set(Number(m[1]), { pid: Number(m[1]), ppid: Number(m[2]), tty: m[3], ageSec: Number(m[4]), args: m[5] });
+  }
+  const self = d.pid ?? process.pid;
+  const hits = [...procs.values()].filter((p) => p.pid !== self && resumedName(p.args));
+  if (!hits.length) return [];
+  const panes = new Map();
+  const lp = d.spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_pid} #{session_name}'], { encoding: 'utf8' });
+  if (lp && !lp.error && lp.status === 0) {
+    for (const l of String(lp.stdout || '').split('\n')) {
+      const m = /^(\d+)\s+(\S+)$/.exec(l.trim());
+      if (m) panes.set(Number(m[1]), m[2]);
+    }
+  }
+  return hits.map((p) => {
+    let tmux = null;
+    for (let pid = p.pid, hops = 0; pid > 1 && hops < 32 && !tmux; hops++) { tmux = panes.get(pid) || null; pid = procs.get(pid)?.ppid ?? (hops === 0 ? p.ppid : 0); }
+    return { name: resumedName(p.args), pid: p.pid, tty: p.tty, tmux, ageSec: p.ageSec };
+  });
+}
+
+export function runGoverned({ program = 'claude', name, args = [], resume = false, noTmux = false, force = false, bin, preattach }, over) {
   const d = defaults(over);
   const n = name || autoName(d.now());
   if (program === 'run') {
@@ -283,6 +393,24 @@ export function runGoverned({ program = 'claude', name, args = [], resume = fals
       return 1;
     }
     alive = r.status === 0;
+    if (!alive && resume && program === 'claude') {
+      const real = findSessionCI(d, PREFIX + full);
+      if (real) {
+        // Same conversation, different case: attach, never start a second Claude.
+        const attach = `tmux attach -t ${real}`;
+        if (!(d.isTTY ?? process.stdout.isTTY)) { d.write(`${n} is already running in tmux ${real}. Attach: ${attach}\n`); return 0; }
+        const a = d.spawnSync('tmux', ['attach-session', '-t', real], { stdio: 'inherit' });
+        return a && typeof a.status === 'number' ? a.status : 0;
+      }
+    }
+  }
+  if (!alive && resume && program === 'claude' && !force) {
+    const [h] = findLiveHolders(d, n);
+    if (h) {
+      const where = h.tmux ? `tmux ${h.tmux}` : `not in tmux on ${h.tty}`;
+      d.write(`${n} is already running (pid ${h.pid}, ${where}). ${h.tmux ? `Attach: tmux attach -t ${h.tmux}. ` : ''}To start a second copy anyway: --force.\n`);
+      return 1;
+    }
   }
   const plan = planLaunch({ name: n, args, env: d.env, alive, resume, noTmux, program, bin, preattach });
   const shown = program === 'run' ? bin : program;
@@ -335,7 +463,7 @@ export function runLs(over) {
     return 1;
   }
   if (!s.length) {
-    d.write('No Quox sessions running. Start one with: quox claude (or quox codex, quox gemini, quox wrap <program>)\n');
+    d.write('No Quox sessions running. Start one with: quox claude (or quox codex, quox wrap <program>)\n');
     return 0;
   }
   const pad = (v, n) => String(v).padEnd(n);

package/lib/core/inboxResolution.js

@@ -41,13 +41,14 @@ export function humanUtc(iso) {
 export function resolutionFromItem(item, requestedAction) {
   if (!item || !item.id) return null;
   const response = item.response || null;
-  const outcome = item.status === 'expired' ? 'expired' : item.status === 'cancelled' ? 'cancelled' : (outcomeOf(response) || 'resolved');
+  const outcome = item.status === 'expired' ? 'expired' : item.status === 'cancelled' ? 'cancelled' : item.status === 'withdrawn' ? 'withdrawn' : (outcomeOf(response) || 'resolved');
   const name = item.resolved_by_name || response?.responded_by_name || null;
   const at = toIso(item.resolved_at) || toIso(response?.responded_at) || null;
   const requested = String(requestedAction || '').trim().toLowerCase() || null;
-  const matches = Boolean(requested) && outcome !== 'expired' && outcome !== 'cancelled' && normalise(requested) === outcome;
+  const matches = Boolean(requested) && outcome !== 'expired' && outcome !== 'cancelled' && outcome !== 'withdrawn' && normalise(requested) === outcome;
   let message;
   if (outcome === 'expired') message = `This approval expired at ${humanUtc(at)}; nothing was approved. Ask for it again.`;
+  else if (outcome === 'withdrawn') message = `This request was withdrawn at ${humanUtc(at)}${name ? ` by ${name}` : ''}; nothing was decided and nothing ran.`;
   else if (outcome === 'cancelled') message = `This item was cancelled at ${humanUtc(at)}${name ? ` by ${name}` : ''}; there is nothing to respond to.`;
   else {
     const head = `Already ${outcome}${name ? ` by ${name}` : ''} at ${humanUtc(at)}`;

package/lib/core/liveSessionsReport.js

@@ -10,7 +10,7 @@ import { spawnSync } from 'node:child_process';
 
 export const TMUX_FORMAT = '#{session_name}\t#{session_created}\t#{session_attached}\t#{pane_current_command}\t#{pane_pid}\t#{session_activity}';
 
-const AGENT_PROGRAMS = new Set(['claude', 'codex', 'gemini']);
+const AGENT_PROGRAMS = new Set(['claude', 'codex']);
 
 /** Parse `tmux list-panes -a -F TMUX_FORMAT` output; one entry per session (first pane wins). */
 export function parseTmuxPanes(out) {

package/lib/core/loginGuard.js

@@ -0,0 +1,73 @@
+/**
+ * Login guards shared by `quox login` and the TUI /login.
+ *  - prefill comes ONLY from the active profile's own last_email
+ *  - a non-default profile signing in as an email another profile already holds gets a y/N warning
+ *  - a 429 says how long to wait (or that retrying may extend the limit)
+ */
+
+/** The active profile's own last_email, or ''. Never another profile's, never a global. */
+export function loginPrefillEmail(config) {
+  try { return String(config.getActiveProfile?.()?.last_email || '').trim(); } catch { return ''; }
+}
+
+/** A server URL reduced to scheme://host:port so https://H, https://h/ and https://h:443 compare equal. '' when not a URL. */
+export function normalizeServerUrl(u) {
+  try { const x = new URL(String(u)); return `${x.protocol}//${x.hostname.toLowerCase()}:${x.port || (x.protocol === 'https:' ? '443' : '80')}`; } catch { return ''; }
+}
+
+/**
+ * Name of ANOTHER profile currently signed in as `email` (case-insensitive), else null.
+ * H2: the same email on a DIFFERENT server is a different account. When `url` (the server this sign-in targets) is
+ * given and the other profile has its own server URL that differs, it does not count. A profile with no URL of its
+ * own is unknown, so it still counts (the safe side for an identity guard).
+ */
+export function profileHoldingEmail(config, email, url = null) {
+  const want = String(email || '').trim().toLowerCase();
+  if (!want) return null;
+  const me = config.getActiveProfileName?.();
+  for (const [name, p] of Object.entries(config._data?.profiles || {})) {
+    if (name === me) continue;
+    if (String(p?.auth?.email || '').trim().toLowerCase() !== want) continue;
+    const mine = normalizeServerUrl(url), theirs = normalizeServerUrl(p?.url);
+    if (mine && theirs && mine !== theirs) continue;
+    return name;
+  }
+  return null;
+}
+
+/** Only a non-default profile needs the warning: it is how agent-only profiles become the owner. */
+export function isNonDefaultProfile(config) {
+  return Boolean(config._data?.activeProfile) && config.getActiveProfileName?.() !== config._data.activeProfile;
+}
+
+export function sameIdentityWarning(email, holder, profile) {
+  return `${email} is already signed in as profile '${holder}'. Sign profile '${profile}' in as the same user? y/N`;
+}
+
+/** Plain-language wait guidance for a rate-limited sign-in. */
+export function rateLimitHint({ retryAfterMs } = {}) {
+  if (Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
+    const min = Math.max(1, Math.ceil(retryAfterMs / 60000));
+    return `Too many authentication attempts: try again in ~${min} min; each retry may extend the limit.`;
+  }
+  return 'Too many authentication attempts: wait a few minutes; retrying now may extend the limit.';
+}
+
+/** Retry-After (seconds or HTTP date) header and common body fields -> ms, else null. */
+export function retryAfterMsFrom(res, data) {
+  const h = res?.headers?.get?.('retry-after');
+  if (h != null && h !== '') {
+    const n = Number(h);
+    if (Number.isFinite(n)) return n * 1000;
+    const t = Date.parse(h);
+    if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  }
+  const s = data?.retry_after ?? data?.retryAfter ?? data?.retry_after_seconds;
+  if (Number.isFinite(Number(s)) && s != null) return Number(s) * 1000;
+  const reset = data?.reset_at ?? data?.resetAt ?? data?.reset;
+  if (reset != null) {
+    const t = typeof reset === 'number' ? (reset < 1e12 ? reset * 1000 : reset) : Date.parse(reset);
+    if (Number.isFinite(t)) return Math.max(0, t - Date.now());
+  }
+  return null;
+}

package/lib/core/loopGlyph.js

@@ -0,0 +1,97 @@
+/**
+ * QLOOP-LIVE: render loop events as QuoxGlyph lines (`quox loop watch`).
+ *   ∞ QLOOP │ turn 3/10 │ wrote report.md · 41s ✔
+ *
+ * Pure: event in, string out, so the watch loop, the tests and anything else that wants the same
+ * voice (the TUI card's observe lines) share one renderer. The ∞ icon is claimed here by extending
+ * the exported registry at import time (the vendored quoxglyph.js is source-locked to the package).
+ */
+
+import { ICONS, STATUS, brandName } from './quoxglyph.js';
+
+ICONS.qloop = '∞ QLOOP';
+
+const R = '\x1b[0m', DIM = '\x1b[2m';
+const colourOn = () => brandName('x y') !== 'x y';
+
+function oneLine(s, n) {
+  const t = String(s == null ? '' : s).replace(/\s+/g, ' ').trim();
+  return [...t].length > n ? `${[...t].slice(0, n - 1).join('')}…` : t;
+}
+
+/** "41s", "1m12s", "2h03m" */
+export function elapsedLabel(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, '0')}s`;
+  return `${Math.floor(s / 3600)}h${String(Math.floor((s % 3600) / 60)).padStart(2, '0')}m`;
+}
+
+/** One QLOOP line: icon+name, verb, optional result, optional status glyph. Result is NOT budget-truncated here (callers cap it). */
+export function loopLine(verb, result, status) {
+  const col = colourOn();
+  const sep = col ? `${DIM}│${R}` : '│';
+  let out = `${brandName(ICONS.qloop)} ${sep} ${verb}`;
+  if (result) out += ` ${sep} ${result}`;
+  const s = status && STATUS[status];
+  if (s) out += ' ' + (col && s.rgb ? `\x1b[38;2;${s.rgb[0]};${s.rgb[1]};${s.rgb[2]}m${s.glyph}${R}` : s.glyph);
+  return out;
+}
+
+const OBSERVE_STATUS = { interval: 'busy', milestone: 'ok', error: 'fail', approval: 'warn', stall: 'warn' };
+
+/**
+ * @param {object} e   a loop event (design section 1)
+ * @param {object} ctx { title, maxTurns, startedMs, spool }
+ * @returns {string[]} lines to print (may be empty)
+ */
+export function renderEvent(e, ctx = {}) {
+  const max = ctx.maxTurns ? `/${ctx.maxTurns}` : '';
+  const since = ctx.startedMs ? ` · ${elapsedLabel(Date.parse(e.at) - ctx.startedMs)}` : '';
+  switch (e.type) {
+    case 'loop.started': {
+      const scope = Array.isArray(e.scope) && e.scope.length ? e.scope.join(',') : 'none';
+      return [loopLine('started', `host ${e.host} · ${e.backend} · scope ${oneLine(scope, 60)}${e.max_turns ? ` · ${e.max_turns} turns max` : ''}`, 'busy')];
+    }
+    case 'loop.turn.started':
+      return ctx.spool ? [loopLine(`turn ${e.turn}${max}`, 'working', 'busy')] : [];
+    case 'loop.turn.output':
+      return ctx.spool ? String(e.chunk).replace(/\n+$/, '').split('\n').map((l) => `  │ ${l}`) : [];
+    case 'loop.turn.tool': {
+      if (e.note) return [loopLine(`turn ${e.turn}`, `${e.tool} no result (${oneLine(e.note, 60)})${since}`, 'warn')];
+      if (e.denied) return [loopLine(`turn ${e.turn}`, `${e.tool} denied: ${oneLine(e.denied, 60)}${since}`, 'warn')];
+      return [loopLine(`turn ${e.turn}`, `${e.tool} ${e.ok ? 'ok' : 'failed'}${e.ms ? ` ${e.ms}ms` : ''}${since}`, e.ok ? 'ok' : 'fail')];
+    }
+    case 'loop.turn.completed':
+      return [loopLine(`turn ${e.turn}${max}`, `${oneLine(e.summary, 70)}${since}`, 'ok')];
+    case 'loop.observe':
+      if (e.kind === 'milestone') return [loopLine('milestone', oneLine(e.text, 100), 'ok')];
+      return [loopLine(e.kind === 'interval' ? 'status' : e.kind, oneLine(e.text, 110), OBSERVE_STATUS[e.kind] || 'busy')];
+    case 'loop.ward':
+      if (e.status === 'pending') return []; // announced, not yet witnessed: nothing to say yet
+      return [loopLine('receipt', `${String(e.envelope_id).slice(0, 12)} ${e.status}`, e.status === 'WITNESSED' ? 'ok' : 'warn')];
+    case 'loop.approval':
+      return [loopLine('approval', `${oneLine(e.what, 90)} (${e.checkpoint_id})`, 'warn')];
+    case 'loop.finished': {
+      // Only a clean completion is a tick. completed_with_errors and a halt / interruption warn; a failure fails. The reason is
+      // whole (a wrapped line beats a cut sentence) and loses the raw component prefix the spawner puts first.
+      const status = e.state === 'completed' ? 'ok' : e.state === 'failed' ? 'fail' : 'warn';
+      const wit = e.receipts != null ? `, ${e.witnessed}/${e.receipts} witnessed` : '';
+      const reason = String(e.reason || '').replace(/\s+/g, ' ').trim().replace(/^[a-z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*:\s+/, '');
+      const why = e.state !== 'completed' && reason ? `: ${reason}` : '';
+      return [loopLine(oneLine(ctx.title || 'loop', 48), `${e.state}, ${e.turns} turn${e.turns === 1 ? '' : 's'}${wit}${why}`, status)];
+    }
+    default:
+      return [];
+  }
+}
+
+/** Exit code for a finished loop: 0 completed (also with errors), 1 failed, 2 halted by a human, 3 interrupted. */
+export function exitCodeFor(state) {
+  switch (state) {
+    case 'completed': case 'completed_with_errors': return 0;
+    case 'halted': return 2;
+    case 'interrupted': return 3;
+    default: return 1;
+  }
+}

package/lib/core/offload.js

@@ -192,22 +192,32 @@ export async function connect(deps, w) {
 export function setupScript(nodeMajor, { docker = false } = {}) {
   return [
     'set -e',
+    // set -e does not fire inside an && list or on the left of a pipe, so every install step below ends in || exit
+    'set -o pipefail',
     'SUDO=""; [ "$(id -u)" = 0 ] || SUDO="sudo -n"',
     `NEED=${Number(nodeMajor)}`,
     'export DEBIAN_FRONTEND=noninteractive',
+    // A fresh pool VM runs apt-daily/unattended-upgrades at boot; wait for it (bounded) instead of failing on the dpkg lock
+    'for i in $(seq 1 120); do pgrep -x apt-get >/dev/null || pgrep -f unattended-upgr >/dev/null || pgrep -x dpkg >/dev/null || break; sleep 5; done',
+    'APT="$SUDO apt-get -o DPkg::Lock::Timeout=600"',
     'MISSING=""',
     'for p in git rsync build-essential python3 curl ca-certificates; do dpkg -s $p >/dev/null 2>&1 || MISSING="$MISSING $p"; done',
-    'if [ -n "$MISSING" ]; then $SUDO apt-get update -qq && $SUDO apt-get install -y -qq $MISSING; fi',
+    'if [ -n "$MISSING" ]; then { $APT update -qq && $APT install -y -qq $MISSING; } || { echo "offload setup: apt install of$MISSING failed" >&2; exit 1; }; fi',
     'HAVE=$(node -p "process.versions.node.split(\'.\')[0]" 2>/dev/null || echo none)',
-    'if [ "$HAVE" != "$NEED" ]; then curl -fsSL https://deb.nodesource.com/setup_$NEED.x | $SUDO -E bash - && $SUDO apt-get install -y -qq nodejs; fi',
+    // a worker already on a NEWER major is fine (callers on this box run 20 and 22); never flip it between majors
+    'case "$HAVE" in none|"") HAVE=0;; esac',
+    'if [ "$HAVE" -lt "$NEED" ]; then { curl -fsSL https://deb.nodesource.com/setup_$NEED.x | ${SUDO:+$SUDO -E} bash - && $APT install -y -qq nodejs; } || { echo "offload setup: node $NEED install failed" >&2; exit 1; }; fi',
     ...(docker ? [
       // --docker: the daemon plus buildx (the sandbox Dockerfiles use COPY --chmod, which needs BuildKit)
       'DMISSING=""',
       'for p in docker.io docker-buildx; do dpkg -s $p >/dev/null 2>&1 || DMISSING="$DMISSING $p"; done',
-      'if [ -n "$DMISSING" ]; then $SUDO apt-get update -qq && $SUDO apt-get install -y -qq $DMISSING; fi',
+      'if [ -n "$DMISSING" ]; then { $APT update -qq && $APT install -y -qq $DMISSING; } || { echo "offload setup: docker install failed" >&2; exit 1; }; fi',
       '$SUDO systemctl enable --now docker >/dev/null 2>&1 || true',
       `id -nG ${REMOTE_USER} | grep -qw docker || $SUDO usermod -aG docker ${REMOTE_USER}`,
     ] : []),
+    // Never record a worker as ready unless the toolchain is really there (2026-10-20: workers marked ready with no npm).
+    'command -v npm >/dev/null || { echo "offload setup: npm missing after setup" >&2; exit 1; }',
+    '[ "$(node -p "process.versions.node.split(\'.\')[0]")" -ge "$NEED" ] || { echo "offload setup: node is older than $NEED" >&2; exit 1; }',
     `mkdir -p ${REMOTE_ROOT}`,
   ].join('\n');
 }
@@ -236,18 +246,21 @@ export function sandboxImagesScript(root, sudo = 'sudo -n') {
   ].join('\n');
 }
 
+export const SETUP_REV = 2;
+
 export async function ensureTooling(deps, w, { docker = false } = {}) {
   const st = loadState(deps);
   const major = String(deps.nodeVersion).replace(/^v/, '').split('.')[0];
-  const done = String(st.worker?.setup || '');
+  // SETUP_REV: bumped when the setup script's guarantees change, so a worker recorded under an older script redoes setup.
+  const done = String(st.worker?.setup || '').startsWith(`r${SETUP_REV}:`) ? String(st.worker.setup).slice(`r${SETUP_REV}:`.length) : '';
   // setup is recorded as "<node major>" or "<node major>+docker"; a docker run needs the +docker form
-  if (st.worker?.vmid === w.vmid && done.split('+')[0] === major && (!docker || done.endsWith('+docker'))) return false;
+  if (st.worker?.vmid === w.vmid && Number(done.split('+')[0]) >= Number(major) && (!docker || done.endsWith('+docker'))) return false;
   const withDocker = docker || done.endsWith('+docker');
   deps.log(`preparing the worker (node, git, rsync, build tools${withDocker ? ', docker' : ''})...`);
   const r = await ssh(deps, w.ip, `bash -c ${shq(setupScript(major, { docker: withDocker }))}`);
   if (r.status !== 0) throw new OffloadError(`worker setup failed (exit ${r.status}): ${r.cmdline}\n${(r.stderr || '').trim()}`);
   const st2 = loadState(deps);
-  if (st2.worker) { st2.worker.setup = withDocker ? `${major}+docker` : major; saveState(deps, st2); }
+  if (st2.worker) { st2.worker.setup = `r${SETUP_REV}:` + (withDocker ? `${major}+docker` : major); saveState(deps, st2); }
   return true;
 }
 
@@ -255,7 +268,13 @@ export async function ensureTooling(deps, w, { docker = false } = {}) {
 // Before a sync, drop synced dirs idle longer than the limit (dir mtime = last use, touched at every sync), never the
 // one being synced and never one a run is busy in (.offload-busy younger than 6h; an older one is a crashed run).
 export const PRUNE_IDLE_MIN = 120;
-export function pruneScript(root, keep, maxIdleMin = PRUNE_IDLE_MIN) {
+// Under disk pressure (free below minFreePct) the least recently used synced dirs go too, oldest first, never the
+// current one or a busy one, until free space reaches targetFreePct (2026-10-20: ~30 dirs all used within the hour
+// filled the shared worker and the idle rule freed nothing).
+export const PRUNE_MIN_FREE_PCT = 20;
+export const PRUNE_TARGET_FREE_PCT = 35;
+const DF_FREE_PCT = 'df -P . | awk \'NR==2 { gsub("%", "", $5); print 100 - $5 }\'';
+export function pruneScript(root, keep, maxIdleMin = PRUNE_IDLE_MIN, { minFreePct = PRUNE_MIN_FREE_PCT, targetFreePct = PRUNE_TARGET_FREE_PCT, freePctCmd = DF_FREE_PCT } = {}) {
   return [
     `cd ${shq(root)} 2>/dev/null || exit 0`,
     'for d in */; do d=${d%/}; [ -d "$d" ] || continue',
@@ -265,6 +284,16 @@ export function pruneScript(root, keep, maxIdleMin = PRUNE_IDLE_MIN) {
     'done',
     // cache entries nobody has used for a day go too (each worktree's copy is only hard links into these)
     `find ${shq(`${root}/.nm-cache`)} -mindepth 1 -maxdepth 1 -mmin +1440 -exec rm -rf {} + 2>/dev/null; true`,
+    `free_pct() { ${freePctCmd}; }`,
+    `if [ "$(free_pct)" -lt ${Number(minFreePct)} ]; then`,
+    '  for d in $(ls -1tr); do [ -d "$d" ] || continue',
+    `    [ "$(free_pct)" -ge ${Number(targetFreePct)} ] && break`,
+    `    [ "$d" = ${shq(keep)} ] && continue`,
+    '    [ -e "$d/.offload-busy" ] && [ -n "$(find "$d/.offload-busy" -mmin -360 2>/dev/null)" ] && continue',
+    '    rm -rf -- "$d"',
+    '  done',
+    'fi',
+    'true',
   ].join('\n');
 }
 
@@ -502,3 +531,40 @@ export function gitToplevel(cwd) {
   const r = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
   return r.status === 0 ? r.stdout.trim() : cwd;
 }
+
+// #1485: the git repo root for cwd, or null when cwd is not inside a repo.
+// Unlike gitToplevel (which falls back to cwd), this reports the no-repo case
+// so resolveSyncDir can refuse rather than sync an unbounded tree.
+export function gitRepoRoot(cwd, { run = (c, a, o) => spawnSync(c, a, o) } = {}) {
+  const r = run('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+
+// #1485: resolve the ONE directory offload rsyncs to the shared worker, and
+// refuse an unbounded one. `quox offload` from a non-repo dir used to fall
+// back to cwd, so running it from the home directory rsynced all ~29G of $HOME
+// (including a live token file) onto the worker and filled its disk. The sync
+// must be a bounded git repo root, never $HOME and never an ancestor of it.
+export function resolveSyncDir(cwd, optionDir, { home = os.homedir(), repoRoot = gitRepoRoot } = {}) {
+  const h = path.resolve(home);
+  const guardHome = (dir, what) => {
+    if (dir === h) {
+      throw new OffloadError(`offload refuses to sync your home directory (${dir}). cd into a project repo, or pass --dir <repo-root>.`);
+    }
+    if (h === dir || h.startsWith(dir + path.sep) || dir === path.parse(dir).root) {
+      throw new OffloadError(`offload refuses to sync ${what} (${dir}): it contains your home directory, so the whole tree would be copied to the shared worker. Pass --dir <repo-root>.`);
+    }
+  };
+  if (optionDir) {
+    const d = path.resolve(optionDir);
+    guardHome(d, 'the --dir path');
+    return d;
+  }
+  const root = repoRoot(cwd);
+  if (!root) {
+    throw new OffloadError(`offload must run from inside a git repository (cwd ${cwd} is not one). cd into a repo, or pass --dir <repo-root>. Refusing so your whole home directory is not synced to the shared worker.`);
+  }
+  const d = path.resolve(root);
+  guardHome(d, 'the resolved repo root');
+  return d;
+}

package/lib/core/org-override.js

@@ -20,6 +20,10 @@ import { QuoxValidationError } from './errors.js';
 // Commands where --org legitimately means something other than "act in".
 export const EXEMPT = new Set(['login', 'logout', 'signup', 'org switch', 'invites list', 'invites accept']);
 
+// Verbs that mint a same-user token for the named org themselves (core/crossOrgApprovals.clientForTarget), so --org
+// naming another org is honoured on that org, not refused. Membership is enforced server-side by the mint.
+export const CROSS_ORG = new Set(['approvals list', 'approvals approve', 'approvals deny', 'approvals walkthrough']);
+
 export function commandPath(cmd) {
   const parts = [];
   for (let c = cmd; c && c.parent; c = c.parent) parts.unshift(c.name());
@@ -35,7 +39,7 @@ export function commandPath(cmd) {
  * @throws {QuoxValidationError} when the override differs from the session org
  */
 export function assertOrgOverrideSafe({ override, authData, hasUserToken, command = '' }) {
-  if (!override || !hasUserToken || EXEMPT.has(command)) return;
+  if (!override || !hasUserToken || EXEMPT.has(command) || CROSS_ORG.has(command)) return;
   const want = String(override).toLowerCase();
   const sid = authData?.org_id || null;
   const known = [sid, authData?.org_slug, authData?.org_name]

package/lib/core/output.js

@@ -45,7 +45,7 @@ export function formatOutput(result, options = {}) {
       formatCsv(rows, columns, headers);
       break;
     case 'quiet':
-      formatQuiet(rows, columns);
+      formatQuiet(rows, options.quietColumn ? [options.quietColumn] : columns);
       break;
     default:
       formatTable(rows, columns, headers, options);
@@ -83,9 +83,9 @@ export function formatDetail(obj, options = {}) {
     const label = (labels[field] || field).padEnd(maxLabel + 2);
     const raw = obj[field];
     if (raw !== null && typeof raw === 'object') {
-      console.log(`  ${chalk.dim(label)}${formatNestedValue(raw)}`);
+      console.log(`  ${chalk.dim(label)}${formatNestedValue(raw, 4, options.full === true)}`);
     } else {
-      const value = formatValue(raw);
+      const value = formatValue(raw, options.full === true);
       console.log(`  ${chalk.dim(label)} ${value}`);
     }
   }
@@ -97,15 +97,15 @@ export function formatDetail(obj, options = {}) {
  * Kept local to formatDetail (not folded into formatValue) so formatTable /
  * formatCsv output is unchanged.
  */
-function formatNestedValue(value, indent = 4) {
+function formatNestedValue(value, indent = 4, full = false) {
   if (value == null) return ` ${chalk.dim('-')}`;
 
   if (Array.isArray(value)) {
     if (value.length === 0) return ` ${chalk.dim('[]')}`;
     const allPrimitive = value.every(v => v === null || typeof v !== 'object');
-    if (allPrimitive) return ` ${value.map(v => formatValue(v)).join(', ')}`;
+    if (allPrimitive) return ` ${value.map(v => formatValue(v, full)).join(', ')}`;
     return '\n' + value
-      .map(v => `${' '.repeat(indent)}- ${typeof v === 'object' && v !== null ? formatNestedValue(v, indent + 2).trimStart() : formatValue(v)}`)
+      .map(v => `${' '.repeat(indent)}- ${typeof v === 'object' && v !== null ? formatNestedValue(v, indent + 2, full).trimStart() : formatValue(v, full)}`)
       .join('\n');
   }
 
@@ -115,9 +115,9 @@ function formatNestedValue(value, indent = 4) {
     .map(k => {
       const v = value[k];
       if (v !== null && typeof v === 'object') {
-        return `${' '.repeat(indent)}${chalk.dim(k + ':')}${formatNestedValue(v, indent + 2)}`;
+        return `${' '.repeat(indent)}${chalk.dim(k + ':')}${formatNestedValue(v, indent + 2, full)}`;
       }
-      return `${' '.repeat(indent)}${chalk.dim(k + ':')} ${formatValue(v)}`;
+      return `${' '.repeat(indent)}${chalk.dim(k + ':')} ${formatValue(v, full)}`;
     })
     .join('\n');
 }