quoxcli 0.4.0 → 0.6.0

package/lib/quoxon/slash/restart.js

@@ -11,6 +11,7 @@ import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync
 import { delimiter, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
+import { isWebPty, SHELL_REFUSED } from '../webPty.js';
 
 /** The CLI tree this code runs from (…/cli). */
 export const RUNNING_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
@@ -170,6 +171,8 @@ export const RESTART_NOTE_ENV = 'QUOX_RESTART_NOTE';
 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';
+/** Env var carrying the slot this window declined to reattach to ("n" at the startup ask), so a restart does not re-ask. */
+export const RESTART_DECLINED_ENV = 'QUOX_RESTART_DECLINED';
 
 /** 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\x1b[?1006l\x1b[?1002l\x1b[?1000l'; // bracketed paste, focus, cursor; mouse tracking off (QUOXON-MOUSE)
@@ -184,13 +187,14 @@ export function restoreTerminal({ stdin = process.stdin, stdout = process.stdout
  * 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) }) {
+export function restartPlan({ argv, conversationId, profile = null, name = null, slot = null, attach = null, org = null, mode = null, declined = 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)
+  if (declined) childEnv = { ...childEnv, [RESTART_DECLINED_ENV]: declined }; // and a declined reattach (never re-asked after a restart)
   const [cmd, lead] = restartTarget(env, bin);
   return { cmd, args: [...lead, ...args], env: childEnv };
 }
@@ -201,15 +205,16 @@ export function restartPlan({ argv, conversationId, profile = null, name = null,
  * 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, 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 });
+export function execRestart({ argv, conversationId, profile = null, name = null, slot = null, attach = null, org = null, mode = null, declined = null, env = process.env, spawn = spawnSync, bin = findOnPath('quox', env), restore = restoreTerminal }) {
+  if (isWebPty(env)) return { error: SHELL_REFUSED, bin: null }; // QUOXON web PTY: reconnect the page instead of re-exec
+  const plan = restartPlan({ argv, conversationId, profile, name, slot, attach, org, mode, declined, env, bin });
   restore(); // the child owns the terminal now
   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 };
 }
 
-export const SERVER_WAIT_EVERY_MS = 2000; // poll the collector /health this often while a restart waits for it
+export const SERVER_WAIT_EVERY_MS = 10000; // poll the collector /health this often while a restart waits for it
 export const SERVER_WAIT_MAX_MS = 3 * 60 * 1000; // ...for up to this long, then carry on as before
 
 /** Poll `probe` (-> { ok } | truthy/falsy, may throw) until it answers ok. -> true when healthy, false on timeout or cancel. */

package/lib/quoxon/slash/stepUp.js

@@ -211,7 +211,7 @@ export function createStepUp({ api, agentLogin = false, onAgentLogin = () => {},
     if (!card) return;
     if (res?.step_up_token) {
       const until = now() + WINDOW_MS;
-      for (const s of res.scopes || card.scopes) tokens.set(s, { token: res.step_up_token, until });
+      if (!card.fresh) for (const s of res.scopes || card.scopes) tokens.set(s, { token: res.step_up_token, until }); // a fresh (one-shot) token is handed to the caller only, never kept
       if (card.window) presentUntil = until;
       card.phase = 'ok'; card.until = until; card.now = now(); refresh(); emit({ type: 'stepup.result', ok: true });
       await sleep(RESULT_HOLD_MS);
@@ -245,16 +245,16 @@ export function createStepUp({ api, agentLogin = false, onAgentLogin = () => {},
     view() { return card ? { ...card, filled: box.count(), tries, now: now() } : null; },
     /**
      * Ask for a person. Resolves { ok, token?, reason? } and never throws. Reuses a live token for the scope.
-     * opts: { scope: 'approve'|'override', scopes?, orgId?, subject?, window?: true (the /authenticate window) }
+     * opts: { scope: 'approve'|'override', scopes?, orgId?, subject?, window?: true (the /authenticate window), fresh?: true (always ask for the PIN, never reuse a live token, never keep the one issued: for one-shot strict tokens) }
      */
-    request({ scope = 'approve', scopes = null, orgId = null, subject = {}, window: asWindow = false, title = null } = {}) {
+    request({ scope = 'approve', scopes = null, orgId = null, subject = {}, window: asWindow = false, title = null, fresh = false } = {}) {
       if (typeof agentLogin === 'function' ? agentLogin() : agentLogin) { note(`This window is an agent login: ${NEEDS_PERSON}.`, 'warn'); onAgentLogin(); return Promise.resolve({ ok: false, reason: 'agent_login' }); }
-      if (!asWindow && live(scope)) return Promise.resolve({ ok: true, token: live(scope).token, scopes: [scope], reused: true });
+      if (!asWindow && !fresh && live(scope)) return Promise.resolve({ ok: true, token: live(scope).token, scopes: [scope], reused: true });
       if (card) return Promise.resolve({ ok: false, reason: 'busy' });
       if (lockedUntil > now()) { note(`⛔ LOCKED · PIN entry is locked for ${mmss(lockedUntil - now())}. Use your phone or a human session.`, 'error'); return Promise.resolve({ ok: false, reason: 'locked' }); }
       tries = MAX_TRIES;
       box.clear();
-      card = { phase: 'input', subject, title, scope, scopes: scopes || (asWindow ? ['approve', 'override'] : [scope]), orgId, window: asWindow, error: null, offset: 0 };
+      card = { phase: 'input', subject, title, scope, scopes: scopes || (asWindow ? ['approve', 'override'] : [scope]), orgId, window: asWindow, fresh, error: null, offset: 0 };
       refresh();
       return new Promise((r) => { resolveCard = r; });
     },

package/lib/quoxon/slash/stepUpCmds.js

@@ -8,6 +8,8 @@
  *                            witnessed server-side. Honest about block types no gate honours yet.
  */
 import { mmss, NEEDS_PERSON } from './stepUp.js';
+import { STEP_UP_HEADER } from '../../core/stepUpPrompt.js';
+import { renderAnnounce } from '../../core/announce.js';
 
 export const BLOCK_TYPES = ['safety', 'budget', 'aocl', 'ward'];
 export const MIN_REASON = 8;
@@ -43,8 +45,79 @@ export function declinedText(reason) {
   }
 }
 
-export function createStepUpCmds({ api, stepUp, say, lastBlock = () => null, orgOf = () => null }) {
+export const verifyEmailUsage = '/verify-email <email> --reason "<why>" [--user-id <id>]  (instance admin; a person confirms with a PIN; audited)';
+const PIN_SHAPED = /(^|\D)\d{6}(\D|$)/;
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;]*m/g;
+
+/** Split on spaces, honouring "double" and 'single' quotes. */
+function words(s) {
+  const out = []; let cur = ''; let q = null; let has = false;
+  for (const ch of String(s || '')) {
+    if (q) { if (ch === q) q = null; else cur += ch; continue; }
+    if (ch === '"' || ch === "'") { q = ch; has = true; continue; }
+    if (/\s/.test(ch)) { if (has || cur) out.push(cur); cur = ''; has = false; continue; }
+    cur += ch; has = true;
+  }
+  if (has || cur) out.push(cur);
+  return out;
+}
+
+/** -> { ok:true, email, reason, userId } | { ok:false, error }. Never accepts a PIN-shaped argument. */
+export function parseVerifyEmail(args) {
+  const raw = String(args || '');
+  if (PIN_SHAPED.test(raw)) return { ok: false, error: 'That looks like a PIN. Never type your PIN after a command: it is asked for in a private card.' };
+  const w = words(raw);
+  let email = null; let reason = null; let userId = null;
+  for (let i = 0; i < w.length; i += 1) {
+    const t = w[i];
+    if (t === '--reason' || t.startsWith('--reason=')) {
+      const parts = t.startsWith('--reason=') ? [t.slice(9)] : [];
+      while (i + 1 < w.length && !w[i + 1].startsWith('--')) { i += 1; parts.push(w[i]); }
+      reason = parts.join(' ').trim();
+    } else if (t === '--user-id' || t.startsWith('--user-id=')) {
+      userId = t.startsWith('--user-id=') ? t.slice(10) : (w[i + 1] && !w[i + 1].startsWith('--') ? w[++i] : '');
+    } else if (!email && !t.startsWith('--')) email = t;
+    else return { ok: false, error: `Unexpected "${t}". Usage: ${verifyEmailUsage}` };
+  }
+  if (!email) return { ok: false, error: `Give the email address. Usage: ${verifyEmailUsage}` };
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) return { ok: false, error: `"${email}" is not an email address. Usage: ${verifyEmailUsage}` };
+  if (!reason) return { ok: false, error: `--reason is required: it is recorded in the audit log. Usage: ${verifyEmailUsage}` };
+  return { ok: true, email, reason, userId: userId || null };
+}
+
+export function createStepUpCmds({ api, stepUp, say, lastBlock = () => null, orgOf = () => null, confirm = null }) {
   return {
+    /** The composer line after the /verify-email preview: true when consumed as the y/n answer. */
+    answer: (text) => Boolean(confirm?.answer(text)),
+    pending: () => Boolean(confirm?.pending()),
+    touch: () => confirm?.touch(),
+    /**
+     * /verify-email: the TUI front of `quox admin users verify-email`. Same endpoint, same scope ('override'); the
+     * server (instance admin, human caller, one-shot step-up token, reason) is the only gate. Preview + y/N first,
+     * then the hidden PIN card, always fresh: a live /authenticate token is never reused or spent here.
+     */
+    async verifyEmail(args) {
+      const p = parseVerifyEmail(args);
+      if (!p.ok) return say(p.error, 'warn');
+      if (!confirm) return say('/verify-email is not available in this mode.', 'warn');
+      const verb = `admin verify-email ${p.email}`;
+      const glyph = (opts) => renderAnnounce('quox', verb, opts).replace(ANSI, '');
+      say(`This will mark ${p.email} as email-verified WITHOUT a mailbox check${p.userId ? ` (only if it belongs to user ${p.userId})` : ''}. Reason (recorded in the audit log under your name): ${p.reason}`, 'warn');
+      say('A person must confirm with the step-up PIN next, asked in a private card. Instance admins only.');
+      return confirm.ask([], async () => {
+        const r = await stepUp.request({ scope: 'override', fresh: true, orgId: orgOf(), title: 'VERIFYING AN EMAIL NEEDS A PERSON', subject: { line1: `verify ${p.email}` } });
+        if (!r.ok) return say(`Not verified: ${declinedText(r.reason)}.`, 'warn');
+        try {
+          const data = await api.verifyEmail({ email: p.email, reason: p.reason, userId: p.userId, stepUp: { [STEP_UP_HEADER]: r.token } });
+          say(glyph({ result: `verified · user ${data.user_id}` }), 'ok');
+          say(`Email ${data.email} is now verified. Reason recorded in the audit log.`, 'ok');
+        } catch (e) {
+          say(glyph({ result: String(e?.body?.message || e?.body?.error || e?.message || e).replace(/\s+/g, ' ').trim(), status: 'fail' }), 'error');
+        }
+        return undefined;
+      }, { prompt: 'Go ahead and ask for your PIN?' });
+    },
     async authenticate() {
       const r = await stepUp.request({ window: true, orgId: orgOf(), subject: { line1: 'confirm a person is at this keyboard' } });
       if (!r.ok) return say(`Not authenticated: ${declinedText(r.reason)}.`, 'warn');

package/lib/quoxon/slashSpinner.js

@@ -0,0 +1,35 @@
+/**
+ * INSTANT-FEEDBACK (owner 2026-10-26: "no spinner... I want a whirly thing like the npm install cursor"): one shared
+ * helper for every async slash command. The dispatcher wraps the handler; if it is still pending after `firstMs`
+ * (under 100 ms) a `⠋ <verb>…` line appears and turns at `frameMs`; it goes away when the handler settles (the result
+ * line or the error replaces it), when the handler prints its first line (`stop`), or after `maxMs`.
+ */
+export const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+/** `/inbox read all` -> `inbox`; the verb is the command word without its slash. */
+export const spinnerVerb = (line) => String(line || '').trim().split(/\s+/)[0].replace(/^\/+/, '') || 'working';
+export const spinnerText = (verb, i = 0) => `${SPIN_FRAMES[i % SPIN_FRAMES.length]} ${verb}…`;
+
+/**
+ * Run `fn` (returns a value or a promise). show(text) paints a frame, hide() clears it. register(stop) hands the caller
+ * a way to cancel the spinner early. Always resolves/rejects exactly as fn does.
+ */
+export async function runWithSpinner(fn, { verb, show, hide, register, firstMs = 80, frameMs = 80, maxMs = 60000 } = {}) {
+  let frame = 0, shown = false, done = false, first = null, iv = null, cap = null;
+  const stop = () => {
+    done = true;
+    if (first) { clearTimeout(first); first = null; }
+    if (iv) { clearInterval(iv); iv = null; }
+    if (cap) { clearTimeout(cap); cap = null; }
+    if (shown) { shown = false; hide?.(); }
+  };
+  first = setTimeout(() => {
+    first = null;
+    if (done) return;
+    shown = true; show?.(spinnerText(verb, frame++));
+    iv = setInterval(() => { if (!done) show?.(spinnerText(verb, frame++)); }, frameMs);
+    cap = setTimeout(stop, maxMs);
+  }, firstMs);
+  register?.(stop);
+  try { return await fn(); } finally { stop(); }
+}

package/lib/quoxon/slotAttach.js

@@ -0,0 +1,8 @@
+// Plain-language slot attach (owner 2026-10-28): "attach to hitl slot" is a request for /slot hitl, so the window
+// OFFERS that command (y/N) instead of sending the sentence to the model. Only these two phrasings match.
+const ATTACH = /^\s*(?:attach\s+(?:me\s+)?to\s+(?:the\s+)?|attach\s+(?:the\s+)?|join\s+(?:the\s+)?)([A-Za-z0-9][A-Za-z0-9._-]{0,63})\s+slot\s*[.!]?\s*$/i;
+export function parseSlotAttach(text) {
+  if (typeof text !== 'string' || text.includes('\n') || text.startsWith('/')) return null;
+  const m = ATTACH.exec(text);
+  return m ? m[1] : null;
+}

package/lib/quoxon/slotChat.js

@@ -12,6 +12,8 @@ import { join, dirname, basename, resolve, isAbsolute } from 'node:path';
 import { scrub } from './transcript.js';
 import { looksLikeKey } from './connect.js';
 import { addressLabel } from './session.js';
+import { isWebPty, FILES_REFUSED } from './webPty.js';
+import { stripForeignAnsi } from './foreignText.js';
 
 // ---- outbound ------------------------------------------------------------------------------------
 const AT_RE = /^@([A-Za-z0-9][A-Za-z0-9-]{0,31}):?[ \t]+(\S[\s\S]*)$/;
@@ -73,7 +75,8 @@ export function redactSecrets(text) {
  * Read a local file for /send. Text up to FILE_CAP goes inline; larger or binary files are refused with the cap
  * (slots have no attachment store). -> { ok, name, path, body, redacted, hits, size } | { ok:false, message }.
  */
-export function prepareFile(p, { cwd = process.cwd() } = {}) {
+export function prepareFile(p, { cwd = process.cwd(), env = process.env } = {}) {
+  if (isWebPty(env)) return { ok: false, message: FILES_REFUSED }; // QUOXON web PTY: no file on the server is ever read for a browser user
   const raw = String(p || '').trim().replace(/^['"]|['"]$/g, '');
   if (!raw) return { ok: false, message: 'Usage: /send <slot> <file>' };
   const full = isAbsolute(raw) ? raw : resolve(cwd, raw.replace(/^~(?=\/)/, homedir()));
@@ -89,7 +92,8 @@ export function prepareFile(p, { cwd = process.cwd() } = {}) {
 }
 
 /** Tab completion for /send's path argument: entries of the typed directory, directories with a trailing slash. */
-export function pathItems(partial, { cwd = process.cwd(), max = 200 } = {}) {
+export function pathItems(partial, { cwd = process.cwd(), max = 200, env = process.env } = {}) {
+  if (isWebPty(env)) return []; // QUOXON web PTY: nothing on the server is listed
   const p = String(partial || '');
   const slash = p.lastIndexOf('/');
   const dirPart = slash >= 0 ? p.slice(0, slash + 1) : '';
@@ -116,9 +120,18 @@ export function slotOfHolder(rows, name) {
   return r ? r.name : null;
 }
 
+/** REPLY-ADDRESS: a message with no from_slot gets one when its sender holds a slot (by held session name, else by the slot's own name). Returns m itself when nothing applies. */
+export function withSenderSlot(rows, m) {
+  if (!m || m.from_slot) return m;
+  const n = String(m.from || '').replace(/\s*\(.*\)\s*$/, '').trim().toLowerCase();
+  const held = (Array.isArray(rows) ? rows : []).filter(x => x?.name && x.state !== 'free');
+  const slot = slotOfHolder(held, m.from) || held.find(x => String(x.name).toLowerCase() === n)?.name || null;
+  return slot ? { ...m, from_slot: slot } : m;
+}
+
 /** A slot message as a chat line: { glyph, who, time, text, file }. */
 export function slotLine(m) {
-  m = m && typeof m.text === 'string' ? { ...m, text: decodeEntities(m.text) } : m;
+  m = m && typeof m.text === 'string' ? { ...m, text: stripForeignAnsi(decodeEntities(m.text)) } : m; // another session's colour codes never show raw
   const f = parseFileMessage(m?.text);
   const file = f ? { name: f.name, meta: f.meta, body: f.body, lines: f.body.split('\n').length, preview: f.body.split('\n').slice(0, 3) } : null;
   // SLOTS-REPLY: the slot is the address, so it leads; the session/display name follows in brackets. A sender
@@ -298,3 +311,11 @@ export function presenceLine(slot, presence, agoText) {
   const seen = presence.last_checked_in_at ? `last checked in ${agoText(presence.last_checked_in_at)}` : 'no check-in on record';
   return { text: `✔ delivered to ${slot} · not listening right now (${seen}); it sees this when it next checks`, tone: 'ok', listening: false };
 }
+
+const DEPLOY_WINDOW_MS = 10 * 60 * 1000;
+/** The "reattach is slow" line. During a deploy (restart signal seen, or the same URL answered within ~10 min) the stale-URL/env advice is wrong, so it says so calmly; a URL that never answered keeps the full diagnostic. */
+export function reattachSlowLine({ slot, message, restartSeenAt = 0, lastGoodAt = 0, now = Date.now() }) {
+  const recent = (t) => Number(t) > 0 && now - Number(t) <= DEPLOY_WINDOW_MS;
+  if (recent(restartSeenAt) || recent(lastGoodAt)) return `slot ${slot}: QuoxCORE is restarting (a deploy); reconnecting, nothing is lost.`;
+  return `slot ${slot}: reattaching after the restart is slow (${message}); retrying.`;
+}

package/lib/quoxon/slotFormat.js

@@ -153,7 +153,7 @@ function wrapRuns(runs, width, role, prefix) {
     let t = a.t;
     if (w + sep + len(t) > room && cur.length) newRow();
     else if (sep) { add({ t: ' ', role, bold: undefined }); w += 1; }
-    while (len(t) > room) { const g = graphemes(t); add({ t: g.slice(0, room - w).join(''), role: a.role, bold: a.bold }); t = g.slice(room - w).join(''); newRow(); }
+    while (len(t) > room) { const g = graphemes(t).map(x => x.text); add({ t: g.slice(0, room - w).join(''), role: a.role, bold: a.bold }); t = g.slice(room - w).join(''); newRow(); }
     add({ t, role: a.role, bold: a.bold }); w += len(t);
     gap = false;
   }

package/lib/quoxon/slotOutbox.js

@@ -0,0 +1,113 @@
+/**
+ * SLOT-OUTBOX: a /say or @slot message that could not be sent because QuoxCORE did not answer (fetch failed,
+ * ECONNREFUSED, socket error, timeout, 5xx) is kept on disk and sent when it answers again, never lost.
+ * Local only (~/.quox/slot-outbox.json, mode 0600, per OS user; each entry also carries the profile it was typed in,
+ * and a window only ever sends its own profile's entries, so a message never changes org).
+ *
+ * Never for a 4xx (auth, permission, no such slot): that is the user's to fix, so the text stays in the prompt.
+ *
+ * ONE-SEND RULE (the slot-say endpoint has no idempotency key, so the client must be conservative):
+ *   1. An entry is flipped to `sending` and persisted BEFORE the request goes out.
+ *   2. Success removes it (it is never sent again).
+ *   3. A clean failure (the server did not answer) puts it back to `queued`.
+ *   4. An entry still `sending` when the file is next read by a process that is not flushing is `unsure`: the window
+ *      died mid-request, so the message may have been delivered. `unsure` entries are never auto-sent; /outbox shows
+ *      them and `/outbox send` (explicit) is the only thing that will try them.
+ *   Residual risk, stated: a timeout where the server did receive the message but the reply was lost can duplicate it
+ *   once on flush. Duplicate over lost is the chosen side for a message the owner typed and saw fail.
+ */
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+export const OUTBOX_CAP = 50;
+export const defaultOutboxPath = (home = homedir()) => join(home, '.quox', 'slot-outbox.json');
+
+/** A send result worth queueing: no HTTP status (fetch failed, refused, socket, timeout) or a 5xx. Never a 4xx, ambiguity, or a licence refusal. */
+export function isConnectivityFailure(r) {
+  if (!r || r.ok || r.ambiguous || r.unlicensed) return false;
+  if (r.status == null) return true;
+  return Number(r.status) >= 500;
+}
+
+export function slotOutbox(path = defaultOutboxPath(), { now = () => Date.now() } = {}) {
+  const read = () => {
+    try { const d = JSON.parse(readFileSync(path, 'utf8')); return Array.isArray(d?.items) ? d : { items: [] }; }
+    catch { return { items: [] }; }
+  };
+  const write = (d) => {
+    try {
+      mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+      const tmp = `${path}.${process.pid}.tmp`;
+      writeFileSync(tmp, JSON.stringify(d), { mode: 0o600 });
+      renameSync(tmp, path);
+      return true;
+    } catch { return false; }
+  };
+  let flushing = false; // this process is mid-flush: its own `sending` entry is live, not crashed
+  const settle = (d) => { // a `sending` entry nobody in this process is sending is a crashed send; persist that verdict
+    if (flushing) return d;
+    let changed = false;
+    for (const it of d.items) if (it.status === 'sending') { it.status = 'unsure'; changed = true; }
+    if (changed) write(d);
+    return d;
+  };
+  const mine = (it, profile) => profile == null || it.profile == null || it.profile === profile;
+  return {
+    /** Entries in send order (oldest first), optionally only this profile's. */
+    list: ({ profile = null } = {}) => settle(read()).items.filter(i => mine(i, profile)),
+    /** -> { ok:true, item, count } | { ok:false, full:true, count }. The cap is on entries not yet sent. */
+    enqueue({ slot, text, profile = null }) {
+      const d = settle(read());
+      if (d.items.length >= OUTBOX_CAP) return { ok: false, full: true, count: d.items.length };
+      const item = { id: `ob_${now().toString(36)}_${randomBytes(3).toString('hex')}`, slot, text: String(text), profile, created_at: new Date(now()).toISOString(), status: 'queued', tries: 0 };
+      d.items.push(item);
+      if (!write(d)) return { ok: false, unsaved: true, count: d.items.length };
+      return { ok: true, item, count: d.items.filter(i => mine(i, profile)).length };
+    },
+    /** Remove the Nth entry (1-based, as /outbox lists this profile's). -> the dropped item, or null. */
+    drop(n, { profile = null } = {}) {
+      const d = settle(read());
+      const visible = d.items.filter(i => mine(i, profile));
+      const it = visible[Number(n) - 1];
+      if (!it) return null;
+      d.items = d.items.filter(i => i.id !== it.id);
+      write(d);
+      return it;
+    },
+    /**
+     * Send what is queued, in order, once. send(item) -> { ok:true } | { ok:false, retryable }. A retryable failure stops
+     * the flush (the server is still down; order is kept). A non-retryable one marks that entry `failed` and moves on.
+     * `includeUnsure` (explicit /outbox send only) also tries entries that may already have been delivered.
+     * -> { sent:[items], failed:[items {error}], pending:n, busy? }.
+     */
+    async flush(send, { profile = null, includeUnsure = false } = {}) {
+      if (flushing) return { sent: [], failed: [], pending: 0, busy: true };
+      flushing = true;
+      const sent = []; const failed = [];
+      try {
+        const ids = settle(read()).items.filter(i => mine(i, profile) && (i.status === 'queued' || (includeUnsure && i.status === 'unsure'))).map(i => i.id);
+        for (const id of ids) {
+          const d = read();
+          const it = d.items.find(i => i.id === id);
+          if (!it || !(it.status === 'queued' || it.status === 'unsure')) continue; // dropped or sent meanwhile
+          it.status = 'sending'; it.tries = (it.tries || 0) + 1; write(d); // persisted BEFORE the request
+          let r;
+          try { r = await send(it); } catch (e) { r = { ok: false, retryable: true, error: e?.message }; }
+          const after = read();
+          const cur = after.items.find(i => i.id === id);
+          if (r?.ok) { after.items = after.items.filter(i => i.id !== id); write(after); sent.push(it); continue; }
+          if (cur) { cur.status = r?.retryable === false ? 'failed' : 'queued'; if (r?.error) cur.error = String(r.error); write(after); }
+          if (r?.retryable === false) { failed.push({ ...it, error: r.error || 'refused' }); continue; }
+          break; // still not answering: keep the rest, in order, for the next recovery
+        }
+      } finally { flushing = false; }
+      return { sent, failed, pending: settle(read()).items.filter(i => mine(i, profile) && i.status === 'queued').length };
+    },
+  };
+}
+
+export const queuedLine = (slot, count) => `⏸ queued for ${slot}: will send when QuoxCORE answers (${count} queued) · /outbox`;
+export const sentLine = (slot) => `✔ sent queued message to ${slot}`;
+export const fullLine = (cap = OUTBOX_CAP) => `Outbox is full (${cap} queued). Not queued: your text is back in the prompt. /outbox shows them, /outbox drop N removes one, /outbox send retries now.`;

package/lib/quoxon/slotRun.js

@@ -21,6 +21,7 @@ import { codeRows } from './slotFormat.js';
 import { graphemes } from './textBuffer.js';
 import { TERMINAL_RESTORE } from './slash/restart.js';
 import { PASTE_ON } from './keys.js';
+import { isWebPty, SHELL_REFUSED } from './webPty.js';
 
 export const RUN_TTL_MS = 10 * 60 * 1000;
 export const RUN_MAX_LEN = 2000;
@@ -105,6 +106,7 @@ export function runAskRows(req, width) {
  * over it. -> { code, signal, ms } | { error, ms }.
  */
 export function handOverRun({ cmd, file = null, args = null, env = process.env, cwd = process.cwd(), stdout = null, setRawMode = null, spawn = spawnSync, shell, now = Date.now, resume = '' }) {
+  if (isWebPty(env)) return { error: SHELL_REFUSED, ms: 0 }; // QUOXON web PTY: never hand a browser terminal a local program
   const tty = Boolean(stdout?.isTTY);
   const rows = tty ? Math.max(0, Number(stdout.frameRows) || 0) : 0;
   const put = (s) => { try { stdout.write(Buffer.from(s)); } catch { /* closed */ } };

package/lib/quoxon/suggestCommand.js

@@ -8,7 +8,7 @@
 import { findCommandEntry } from './commands.js';
 
 // Commands that need the human's own typing: never offered, never run from a model suggestion.
-export const HUMAN_TYPED = new Set(['approve', 'yestoall', 'deny', 'authorise', 'authorize', 'authenticate', 'override', 'restart', 'quit', 'exit', 'login']);
+export const HUMAN_TYPED = new Set(['approve', 'yestoall', 'deny', 'authorise', 'authorize', 'authenticate', 'override', 'verify-email', 'restart', 'quit', 'exit', 'login']);
 // Pure views, no effect: may run without asking when explicit, and only with no arguments.
 export const READ_ONLY_VIEWS = new Set(['approvals', 'mind', 'which', 'context', 'rooms', 'active', 'slots']);
 

package/lib/quoxon/term.js

@@ -48,8 +48,19 @@ export function inkStdout(out, { tap = null } = {}) {
     if (cb) out.write('', cb); // nothing to send: still a barrier behind the earlier writes
     return true;
   } : null;
-  return new Proxy(out, {
+  // Resize: Ink repaints its last committed tree at the new width the moment 'resize' fires, which wraps every 78-wide rule for a
+  // beat (owner 2026-10-27: top rule and model label wrapped after 79 -> 58). Listeners for 'resize' run RESIZE_SETTLE_MS late, so
+  // the app (which flags its own listener `resizeFirst`) commits the new column count first and Ink paints the right width once.
+  const lateOf = new WeakMap();
+  const lateListener = (fn) => {
+    if (fn.resizeFirst) return fn;
+    if (!lateOf.has(fn)) lateOf.set(fn, (...a) => { const t = setTimeout(() => fn(...a), RESIZE_SETTLE_MS); t.unref?.(); });
+    return lateOf.get(fn);
+  };
+  const proxy = new Proxy(out, {
     get(target, prop) {
+      if ((prop === 'on' || prop === 'addListener' || prop === 'once') && typeof target[prop] === 'function') return (ev, fn, ...r) => { target[prop](ev, ev === 'resize' && typeof fn === 'function' ? lateListener(fn) : fn, ...r); return proxy; };
+      if ((prop === 'off' || prop === 'removeListener') && typeof target[prop] === 'function') return (ev, fn, ...r) => { target[prop](ev, ev === 'resize' && typeof fn === 'function' ? lateListener(fn) : fn, ...r); return proxy; };
       if (prop === 'write' && write) return write;
       if (prop === 'rows') return Infinity;
       if (prop === 'termRows') return target.rows;
@@ -61,7 +72,20 @@ export function inkStdout(out, { tap = null } = {}) {
     },
     set(target, prop, value) { return Reflect.set(target, prop, value, target); }
   });
+  return proxy;
+}
+const RESIZE_SETTLE_MS = 40;
+
+/**
+ * The width to print history at, read from the terminal NOW. The `cols` state lags a resize (the listener attaches after mount,
+ * and the commit is async), and a <Static> item printed at the stale width is wider than the new terminal, so the terminal
+ * breaks it mid-word. Never wider than the state either (a pinned `columns` prop wins when it is narrower).
+ */
+export function liveCols(stdout, stateCols) {
+  const n = Number(stdout?.columns);
+  return Number.isFinite(n) && n > 0 ? Math.min(stateCols, Math.max(MIN_STATIC_COLS, n - 1)) : stateCols;
 }
+const MIN_STATIC_COLS = 20;
 
 /** Real terminal height, or null when unknown (not a TTY, tests). */
 export function termRows(stdout) {

package/lib/quoxon/transcript.js

@@ -11,6 +11,7 @@ import { stripMarks } from './palette.js';
 import { textGate } from './events.js';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { redactSecrets } from './secretShape.js';
 
 export const MAX_FIELD = 4000;
 export const SILENT_GAP_MS = 10000;
@@ -33,7 +34,7 @@ const SCRUBS = [
 export function scrub(s) {
   let out = String(s);
   for (const [re, rep] of SCRUBS) out = out.replace(re, rep);
-  return out;
+  return redactSecrets(out); // SECRET-GUARD: bank/PIN/card shapes, after the key patterns
 }
 
 /** Strings are scrubbed and truncated; non-strings become a scrubbed JSON string (never a raw object). */

package/lib/quoxon/webPty.js

@@ -0,0 +1,15 @@
+/**
+ * QUOXON web PTY: the dashboard /cli page runs this app in a browser terminal whose process lives on the
+ * collector host. The collector marks that PTY with QUOX_WEB_PTY=1, and every path that would start a local
+ * program (a `!` command, a terminal hand-off, $EDITOR, a command row, a restart re-exec, a URL opener, the
+ * docker offer, an extension import) checks isWebPty() and refuses. A browser user gets the conversation,
+ * never a shell on the server.
+ */
+export const WEB_PTY_ENV = 'QUOX_WEB_PTY';
+export const SHELL_REFUSED = 'shell commands are not available in the browser terminal';
+export const EXTENSIONS_REFUSED = 'extensions are not available in the browser terminal';
+
+export function isWebPty(env = process.env) {
+  return env?.[WEB_PTY_ENV] === '1';
+}
+export const FILES_REFUSED = 'local files are not available in the browser terminal';

package/lib/quoxon/welcome.js

@@ -6,7 +6,7 @@ import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-export const DOCS_URL = 'https://cli.quox.ai/docs/start/'; // #1100: CLI docs "Start here" (cli.quox.ai/docs/ itself has no index page)
+export const DOCS_URL = 'https://quox.ai/cli/'; // #1100: CLI docs start page (cli.quox.ai retired 2026-10-26, moved to quox.ai/cli)
 export const TERMS_URL = 'https://quox.ai/terms';
 export const PRIVACY_URL = 'https://quox.ai/privacy';
 export const LICENCE = 'Quox Community Source Licence 1.0 (source-available)';

package/lib/quoxon/whatsnew.js

@@ -109,7 +109,7 @@ export function listWhatsNew(arg = '', entries = ENTRIES) {
 // Startup preference: quoxon.whatsNewStartup = 'on' | 'off' (default on). Both live in the synced profile settings.
 export const startupEnabled = (settings) => String(settings?.whatsNewStartup || 'on').toLowerCase() !== 'off';
 
-const activeCommands = (registry) => registry.filter(e => e.kind === 'command' && e.status === 'active');
+const activeCommands = (registry) => registry.filter(e => e.kind === 'command' && e.status === 'active' && !e.dyn);
 
 /**
  * Commands the user has not been shown, newest first (registry is oldest first, so reversed). With no record yet

package/lib/quoxon/whatsnew.jsonl

@@ -132,3 +132,45 @@
 {"id": "loop-card-polish", "date": "2026-10-26T13:00:00Z", "since": "0.3.1", "title": "The loop card keeps its own count", "text": "The card now counts the loop's own turns (turn 2 of 5, not the message count), shows the whole runway, fills a receipts bar as each one is witnessed, and says a milestone once. With an empty composer, press Down to reach its keys. A finished loop calls its dragon.", "try": "/loop list"}
 {"id": "org-picker", "date": "2026-10-26T16:30:00Z", "since": "0.3.1", "title": "Switch org in one keystroke", "text": "Type /org for a list of your orgs, arrow to one and press Enter: this window moves there at once and the status bar follows. Press d instead to also make it your default. /org hampshire switches straight away when only one org matches, and quox org switch with no argument gives a numbered list.", "try": "/org"}
 {"id":"quoxcli-0-4-0","date":"2026-10-26T18:00:00Z","since":"0.4.0","title":"quoxon extensions, an inbox bar, history and mouse editing","text":"Add and manage extensions with quox ext add, quox ext remove and quox ext list, or /ext in the window. /inbox and a notification bar show what is waiting. Up and Ctrl+R search your history. /mouse turns on optional mouse editing. Plan approval cards now list their steps, and live loop cards no longer freeze the window.","try":"/ext","shell":"quox ext list"}
+{"id": "dragons-vulcan-quoxperticus", "date": "2026-10-27T09:00:00Z", "since": "0.3.1", "title": "Two new dragons: Vulcan and Quoxperticus", "text": "Two new dragons: Vulcan, the forge dragon, and Quoxperticus, the fleet conductor. Attach either agent and the dragon greets you, listens while you work, waits with you at approvals and shows when something needs attention.", "try": "/attach vulcan"}
+{"id": "quoxon-2026-10-27-honest-window", "date": "2026-10-27T12:30:00Z", "since": "0.4.0", "title": "A calmer, more honest window", "text": "When your model hits a usage limit, the window offers a working one (y/N). Auto-restart waits at least 30 minutes between restarts and only when you are idle; inside that time a new version shows a quiet line and Enter restarts. The status bar no longer says nothing is waiting while items are open or a source can't be read. /say and /observe reach your slots in your other orgs (name@org picks one). /approvals opens faster, and a refused loop shows why instead of fake progress.", "try": "/approvals"}
+{"id": "quoxon-2026-10-27-delete-confirm", "date": "2026-10-27T16:30:00Z", "since": "0.4.0", "title": "Deletes need the name typed", "text": "An approval that deletes something (delete_*, remove_*, purge_*, destroy_*, drop_*, wipe_*) now leads with DELETES and the object, and a single y no longer approves it: y asks you to type the name, Esc or n goes back, n on the card still denies. Bulk approve (/yestoall, /approve all) skips deletes and tells you how many are left to confirm one by one.", "try": "/approvals"}
+{"id": "quoxon-2026-10-28-approval-burst", "date": "2026-10-28T00:30:00Z", "since": "0.4.0", "title": "A burst of approvals is one card", "text": "When one agent asks to run the same tool several times within 5 minutes (say nine wire_alerts), you get ONE card: 'VIGIL wants to run wire_alerts on 9 items'. y approves all, n denies all, p walks them one by one, Tab puts it away. Deletes and risky asks are never in the batch; they keep their own card and confirm. The inbox arrival line collapses the same way.", "try": "/approvals"}
+{"id": "quoxon-2026-10-28-burst-across-polls", "date": "2026-10-28T04:00:00Z", "since": "0.4.0", "title": "Pack installs on many hosts are one card", "text": "DevSuite pack installs filed a few seconds apart for different hosts used to arrive as one card each. They now merge into ONE card (y approves all, n denies all, p picks), and the card says who asked in plain words ('DevSuite (skill-pack sync)') instead of an internal key. Restart, deploy and other disruptive asks still never batch.", "try": "/approvals"}
+{"id": "quoxon-2026-10-28-afk-quiet-cards", "date": "2026-10-28T06:45:00Z", "since": "0.4.0", "title": "Away means quiet", "text": "After /afk or /sleep, new approvals no longer open a card or arm y/n (a stray key cannot answer one). They are only counted: \"⏸ N approvals waiting · /back to review\". /back, or any message you type, opens them as before. Nothing is ever answered for you."}
+{"id": "quoxon-2026-10-28-agent-profile-offer", "date": "2026-10-28T15:00:00Z", "since": "0.4.0", "title": "Opened as an agent? Quox offers your own login", "text": "Starting quox on an agent profile while you have a signed-in human profile now asks once (y/N) to restart as you. Typing \"attach to hitl slot\" offers /slot hitl instead of going to the model."}
+{"id": "quoxon-2026-10-28-secret-paste-guard", "date": "2026-10-28T17:00:00Z", "since": "0.4.0", "title": "Pasted credentials are caught", "text": "A message that looks like bank details, a PIN, a password, a card number or an API key now asks \"Don't send it?\" (y keeps it out, n sends anyway). Nothing is sent or saved on y, and history and transcripts store [REDACTED:kind] in place of the value either way."}
+{"id": "quoxon-2026-10-28-do-not-disturb", "date": "2026-10-28T18:00:00Z", "since": "0.4.0", "title": "Sleep means sleep: /donotdisturb and /morningreport", "text": "/donotdisturb (or /dnd, optionally until 07:30) collects everything quietly: no notices, approval cards, bells or dragon. The status line shows \"🌙 do not disturb · N waiting · /morningreport\". /morningreport groups what came in (incidents first, repeats as ×N) and offers to turn it off. /afk and /sleep imply it, saying you are going to sleep offers it, and a restarted window restores it."}
+{"id": "quoxon-2026-10-29-provider-test-json", "date": "2026-10-29T12:00:00Z", "since": "0.4.0", "title": "quox provider test --json says why", "text": "quox provider test --json now prints every provider's result (ok, error, reason code) and a summary, instead of nothing, and still exits 1 when one fails."}
+{"id": "quoxon-2026-10-29-connect-server-install", "date": "2026-10-29T13:00:00Z", "since": "0.4.0", "title": "quox connect and quox server install", "text": "quox connect links this machine to a Quox server. quox server install sets up a new server on this machine: checks, download, start, owner account and a one-time sign-in link. Try quox server install --dry-run first. The sign-in link is not printed into piped or --json output unless you pass --print-login-link.", "shell": "quox server install --dry-run", "sha": "34a547724"}
+{"id": "quoxon-2026-10-29-morningreport-fallback", "date": "2026-10-29T14:00:00Z", "since": "0.4.0", "title": "/morningreport shows the digest when nothing was held", "text": "With do not disturb off, /morningreport now says nothing was held and shows the same While you were away digest as /away, so you no longer need a second command.", "sha": "c4f2a3c90"}
+{"id": "quoxon-2026-10-29-never-answered-offer", "date": "2026-10-29T15:00:00Z", "since": "0.4.0", "title": "A server that never answered now offers to connect elsewhere", "text": "If this machine has never reached the server a profile points at, Quox now asks whether to connect to a different one instead of waiting on a restart that is not happening. Say y, type the address, and it checks the server, shows its certificate and signs you in."}
+{"id": "quoxon-2026-10-29-approval-outcome", "date": "2026-10-29T16:00:00Z", "since": "0.4.0", "title": "You now see whether an approved action worked", "text": "After you approve a request from another session, Quox follows up with one line saying whether it finished or failed and why. The failed-to-execute notice now carries the approval id, so quox inbox show <id> opens it."}
+{"id": "quoxon-2026-10-29-deck-lazy-offer", "date": "2026-10-29T17:00:00Z", "since": "0.4.0", "title": "/deck now offers to install what it needs", "text": "If quoxdeck is missing, or its audio headers (libasound2-dev) are, /deck on asks once whether to install them, shows the exact commands, and runs them with your own sudo prompt. Say n and it prints the commands to run later."}
+{"id":"quoxon-2026-10-29-connect-no-terminal","date":"2026-10-29T08:50:36Z","since":"0.4.0","title":"quox connect can run with no terminal","text":"quox connect now takes --email, --password-stdin and --fingerprint <sha256>, so a script or chat can connect and sign in with no prompts. quox server status shows the certificate fingerprint to compare, a certificate Quox does not trust now says so in plain words with the fix, and the same email on a different server no longer trips the same-user warning."}
+{"id":"quoxcli-2026-10-29-tls-trust-hint","date":"2026-10-29T09:26:52Z","since":"0.4.0","title":"A certificate Quox does not trust now says so on login","text":"If a server uses a certificate this machine does not trust yet, quox login now says so in plain words and prints the exact quox connect command to trust it (it shows the fingerprint and asks y/N; --trust-cert or --fingerprint for no terminal), instead of just \"fetch failed\"."}
+{"id":"quoxon-2026-10-29-gripe-queue","date":"2026-10-29T09:46:49Z","since":"0.4.0","title":"/gripe no longer loses a gripe when Quox is slow","text":"If /gripe! times out or the server errors, the gripe is saved on your machine and filed when Quox answers again, without making a duplicate issue if the first try had actually gone through. /gripes shows what is waiting and what was filed."}
+{"id":"quoxon-2026-10-29-gripe-paste-lines","date":"2026-10-29T10:10:00Z","since":"0.4.0","title":"/gripe keeps the lines of what you paste","text":"A multi-line paste into /gripe now reaches the issue with its lines intact instead of one run-on line, and the confirm says how many more lines will be filed."}
+{"id":"quoxon-2026-10-29-advice-independent","date":"2026-10-29T11:00:00Z","since":"0.4.0","title":"Test-edit approvals no longer echo the asker as advice","text":"On a test-edit approval card, ADVICE now cites the diff when it is known, or says there is no independent view, instead of repeating the asker's own recommendation; the starred recommended-by line stays."}
+{"id":"quoxon-2026-10-29-resume-no-duplicate","date":"2026-10-29T12:00:00Z","since":"0.4.0","title":"quox claude --resume no longer starts a second copy","text":"Resuming a named session now finds its tmux session whatever the capitals and attaches to it, and refuses with the pid and the attach command when that conversation is already running anywhere. --force starts a second copy on purpose."}
+{"id": "quoxon-2026-10-29-sleep-one-step", "date": "2026-10-29T09:00:00Z", "since": "0.4.0", "title": "/sleep is one step", "text": "/sleep (or /afk going to bed) sets you asleep with do not disturb on in one command. A bare /dnd now only ever turns it on; /dnd off ends it. Plain /afk offers do not disturb with one y/N."}
+{"id": "quoxon-2026-10-29-roster-sessions", "date": "2026-10-29T17:30:00Z", "since": "0.4.0", "title": "/roster shows attached agents and duplicate sessions", "text": "/roster now lists the live agent attaches in your org and every claude --resume process on this box, grouped by name. A conversation running more than once is flagged with each pid. The same attach list is quox agent attaches."}
+{"id": "quoxon-2026-10-29-announce-everything", "date": "2026-10-29T20:00:00Z", "since": "0.4.0", "title": "Quox announces what it does", "text": "Memory saves, approvals, slot messages, connect and vault create now print one Quox line saying what happened, success or failure, and the chat transcript shows the same line for what a turn did (a saved memory, an approval, a delegation). Silent under --json and --quiet.", "shell": "quox memory create --type fact --content hello"}
+{"id": "quoxon-2026-10-29-walkthrough-command", "date": "2026-10-29T22:30:00Z", "since": "0.4.0", "title": "The walkthrough shows the command", "text": "Each approval card in the walkthrough now shows the exact command in full, never cut off, and the host it runs on. When the reason was guessed from the command rather than stated by the asker, it is labelled so.", "try": "/walkthrough"}
+{"id": "quoxon-2026-10-29-chat-quox-lines", "date": "2026-10-29T22:31:00Z", "since": "0.4.0", "title": "quox chat prints what Quox did", "text": "quox chat, streaming or --no-stream, now prints one Quox line on stderr for what a turn did (a saved memory, an approval, a delegation). Silent under --json and --quiet.", "shell": "quox chat --no-stream \"remember that the proof tag is QA-1036\""}
+{"id": "quoxon-2026-10-30-inbox-unread-quiet-noreply", "date": "2026-10-30T07:00:00Z", "since": "0.4.0", "title": "Undo a read, quieter no-reply, honest timeouts", "text": "/inbox unread N puts an item back as unread. The no reply from a slot notice is dim and skipped when that slot spoke in the last 10 minutes. An approved action whose result timed out is titled no result in time (it may still have run) instead of FAILED.", "try": "/inbox unread 1"}
+{"id": "quoxon-2026-10-30-reattach-deploy-line", "date": "2026-10-30T08:00:00Z", "since": "0.4.0", "title": "A slot reattach during a deploy says so", "text": "When QuoxCORE is being redeployed, a slow slot reattach now says it is restarting and reconnecting, instead of suggesting a stale URL or QUOX_COLLECTOR_URL. A URL that never answered still gets the full diagnostic.", "try": "/slot"}
+{"id":"quoxon-2026-10-30-inbox-unread-cli","date":"2026-10-30T08:27:43Z","since":"0.4.0","title":"Mark unread from a shell, read items whole","text":"quox inbox unread <id> undoes a mark-as-read from a shell, and /inbox unread all flips back every read item. /inbox N now shows the full body of every item (it missed the stored body before), the sender and subject for mail, and the actions that apply.","try":"/inbox 1","shell":"quox inbox unread <id>"}
+{"id":"quoxon-2026-10-30-presence-owner-level","date":"2026-10-30T08:56:21Z","since":"0.4.0","title":"Good morning waits for you; /back agrees across windows","text":"LUCID no longer says good morning at 08:00 while you are asleep or away: it waits until you are back. If another window already marked you present, /back reports that same away span instead of its own.","try":"/back"}
+{"id":"quoxon-2026-10-30-tui-mail","date":"2026-10-30T09:30:00Z","since":"0.4.0","title":"Read your email in the terminal: /mail","text":"/mail lists your newest triaged email (sender, subject, age, zone) and /mail N opens one with its body excerpt and why it was triaged that way. Read only: nothing is sent, moved or deleted. With no mailbox connected it names the connect command. /inbox now points at /mail.","try":"/mail"}
+{"id":"quoxon-2026-10-30-dnd-survives-restart","date":"2026-10-30T10:40:24Z","since":"0.4.0","title":"Do not disturb now survives restarts","text":"Do not disturb is saved on the server for you, not just in one window, so an auto-restart no longer drops it, even when the server is slow to answer at that moment: the window keeps retrying until it can read it.","try":"/dnd"}
+{"id":"quoxon-2026-10-30-reply-address","date":"2026-10-30T11:00:00Z","since":"0.4.0","title":"Messages from slot holders now show their reply address","text":"A message from a session that holds a slot no longer says (no reply address): the TUI looks up the slot the sender holds, so Tab or /r replies to it. It says so only when the sender truly holds no slot."}
+{"id":"quoxon-2026-10-30-approval-row-background","date":"2026-10-30T12:00:00Z","since":"0.4.0","title":"Approval rows flag background work","text":"/approvals rows now say when a command runs in the background, including screen, tmux and docker detached runs."}
+{"id":"quoxon-2026-10-30-confirm-target-once","date":"2026-10-30T22:00:00Z","since":"0.4.0","title":"Approval confirmations name the hosts once","text":"The line after you approve a multi-host command no longer repeats the host list twice."}
+{"id":"quoxon-2026-10-30-away-retry","date":"2026-10-30T22:10:00Z","since":"0.4.0","title":"While you were away retries a slow source","text":"If a source times out right after sign-in, the digest asks it once more before it says it cannot see it."}
+{"id":"quoxon-2026-11-06-approval-popup-dedupe","date":"2026-11-06T17:40:00Z","since":"0.4.0","title":"An approval you answered does not pop up again","text":"Approving or denying on the inline prompt now stops the same approval opening a second later as a new walkthrough card."}
+{"id":"quoxon-2026-11-07-resend-held-turn","date":"2026-11-07T12:40:00Z","since":"0.4.0","title":"A message sent during a restart is not lost","text":"If the server already received your message before the connection dropped, Quox now shows that answer instead of failing, and if it cannot, your message comes back to the composer."}
+{"id":"quoxon-2026-11-07-actions-list-fits","date":"2026-11-07T12:30:00Z","since":"0.4.0","title":"quox actions list fits your screen","text":"The list now fits the terminal or the Quox pane: short ids (done, move, get and delete accept them), long titles end in an ellipsis instead of wrapping, and the Due column only shows when an item has a due date. --json keeps the full ids."}
+{"id":"quoxon-2026-11-07-offload-lease-warn","date":"2026-11-07T13:20:00Z","since":"0.4.0","title":"Offload warns before a worker lease runs out","shell":"quox offload leases","text":"quox offload status and the new quox offload leases list every offload worker with EXPIRED, EXPIRING or OK, and every offload command warns when a lease ends within 12 hours, naming the command a human runs to renew it."}
+{"id":"quoxon-2026-11-07-select-dot-whole-result","date":"2026-11-07T13:50:00Z","since":"0.4.0","title":"quox tool exec --select . returns the whole result","text":"A dot means the whole result, as in jq, so --select . (and count(.)) no longer fails with \"bad path\". Every other --select path works as before."}
+{"id":"quoxon-2026-11-08-walk-revalidate","date":"2026-11-08T04:55:00Z","since":"0.4.0","title":"A stopped walkthrough only lists what is still waiting","text":"When a walkthrough stops, the TUI asks the server again before listing what is still waiting, so questions answered from another window drop off the list. A held list is re-checked the same way before its first card. If the server cannot be reached, the list says it may be out of date."}