quoxcli 0.5.0 → 0.6.0

package/lib/quoxon/slash/broadcast.js

@@ -4,7 +4,7 @@
  * fleet and org reach, bulletins and drafting are not built.
  */
 export const BROADCAST_USAGE = 'Usage: /broadcast [--slots a,b] [--priority urgent] [--ack] [--active [--dry-run]] <text>';
-export const PAGE_USAGE = 'Usage: /page <slot> <text>';
+export const PAGE_USAGE = 'Usage: /page <slot>[,<slot>...] <text>  (several slots: a,b,c or a b c)';
 const NOT_YET = new Set(['--fleet', '--org', '--voice', '--at']);
 
 /**
@@ -44,11 +44,35 @@ export function activeLine({ reached = 0, skipped = 0, dryRun = false } = {}) {
   return `\u{1F4CD} QUOXSLOTS \u2502 broadcast to active \u2502 ${reached} ${dryRun ? 'would reach' : 'reached'} \u00B7 ${skipped} skipped dormant \u2714`;
 }
 
-/** `/page <slot> <text>` -> urgent, ack-required, one recipient. */
-export function parsePageArgs(arg) {
-  const m = /^(\S+)\s+([\s\S]*\S[\s\S]*)$/.exec(String(arg || '').trim());
-  if (!m || m[1].startsWith('--')) return { ok: false, message: PAGE_USAGE };
-  return { ok: true, text: m[2].trim(), slots: [m[1].toLowerCase()], priority: 'urgent', ack: true };
+/**
+ * TUI-WAKE-MULTI (owner 2026-11-08): the leading slot names of a /page or /wake line, then the message.
+ * The first name is always a target. A name joined by a tight comma (seer,quoxon) is always a target, known or not,
+ * so an unknown one is reported per slot by the server. A name after a space, or after ", ", is a target only when
+ * it is in `known` (the org's slot names); the first word that is not starts the message, kept exactly as typed.
+ * With no `known` list only the tight comma list is targets. -> { slots: [lowercase, deduped], text } | null.
+ */
+export function splitTargets(arg, known = null) {
+  const set = known ? new Set([...known].map((x) => String(x).toLowerCase())) : null;
+  const slots = []; let rest = String(arg || '').trim(); let tight = true;
+  for (;;) {
+    const m = /^\s*([^\s,]+)/.exec(rest);
+    if (!m) break;
+    const name = m[1].toLowerCase();
+    if (!slots.length && name.startsWith('--')) return null;
+    if (!tight && !(set && set.has(name))) break;
+    slots.push(name); rest = rest.slice(m[0].length);
+    const c = /^\s*,(\s*)/.exec(rest);
+    tight = Boolean(c && !c[1]);
+    if (c) rest = rest.slice(c[0].length);
+  }
+  return slots.length ? { slots: [...new Set(slots)], text: rest.trim() } : null;
+}
+
+/** `/page <slot>[,<slot>...| <known slot>...] <text>` -> urgent, ack-required, every named recipient. */
+export function parsePageArgs(arg, known = null) {
+  const t = splitTargets(arg, known);
+  if (!t || !t.text) return { ok: false, message: PAGE_USAGE };
+  return { ok: true, text: t.text, slots: t.slots, priority: 'urgent', ack: true };
 }
 
 const plural = (n) => (n === 1 ? 'session' : 'sessions');

package/lib/quoxon/slash/broadcastRun.js

@@ -3,7 +3,7 @@
  * One server call fans out (POST /api/v1/slots/broadcast); with --ack the sender then sees the delivery line
  * update as recipients acknowledge. The poll is display only: the broadcast and its acks live on the server.
  */
-import { parseBroadcastArgs, parsePageArgs, parseAckArgs, parseStatusArgs, broadcastSummary, broadcastCard, BROADCAST_USAGE, activeLine } from './broadcast.js';
+import { parseBroadcastArgs, parsePageArgs, splitTargets, parseAckArgs, parseStatusArgs, broadcastSummary, broadcastCard, BROADCAST_USAGE, activeLine } from './broadcast.js';
 
 const roomC = (r) => ({ sent: 0, sending: 0, failed: 0, ...(r?.counts?.room || {}) });
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -20,7 +20,7 @@ export async function runBroadcast({ api, kind, arg, from, say, card = null, isC
     const st = api.slotBroadcastStatus ? await api.slotBroadcastStatus(st0.id) : { ok: false, message: 'not available in this mode' };
     return st.ok ? show(st.data) : say(`Broadcast status failed: ${st.message}`, 'warn');
   }
-  const parsed = kind === 'page' ? parsePageArgs(arg) : parseBroadcastArgs(arg);
+  const parsed = kind === 'page' ? parsePageArgs(arg, await slotNames(api)) : parseBroadcastArgs(arg);
   if (!parsed.ok) return say(parsed.message, parsed.message === BROADCAST_USAGE ? 'plain' : 'warn');
   const r = await api.slotBroadcast({ text: parsed.text, slots: parsed.slots, priority: parsed.priority, ack: parsed.ack, active: parsed.active, ...(parsed.dryRun ? { dryRun: true } : {}), from });
   if (!r.ok) return say(`${kind === 'page' ? 'Page' : 'Broadcast'} failed: ${r.message}`, 'warn');
@@ -72,13 +72,19 @@ export async function runBroadcast({ api, kind, arg, from, say, card = null, isC
 }
 
 /**
- * FORCE-WAKE: `/poke|/wake|/slap|/nudge <slot> [text]`. `--force` is accepted anywhere as a no-op (every human
+ * FORCE-WAKE: `/poke|/wake|/slap|/nudge <slot>[,<slot>...] [text]` (several slots: see splitTargets). `--force` is accepted anywhere as a no-op (every human
  * wake already sets an unsent draft aside and puts it back) and is never page text. null = no slot given.
  */
-export function parsePokeArgs(restArg) {
+export function parsePokeArgs(restArg, known = null) {
   const s = String(restArg || '').replace(/(^|\s)--force(?=\s|$)/g, '$1').trim();
-  const m = /^(\S+)(?:\s+([\s\S]+))?$/.exec(s);
-  return m ? { slot: m[1], text: m[2] ? m[2].trim() : null } : null;
+  const t = splitTargets(s, known); // TUI-WAKE-MULTI: `slot` is the comma-joined target list, /page splits it again
+  return t ? { slot: t.slots.join(','), text: t.text || null } : null;
+}
+
+/** The org's slot names for splitTargets, or null when they cannot be read (then only a comma list is targets). */
+export async function slotNames(api) {
+  if (!api?.slots) return null;
+  try { const rows = await api.slots(); return Array.isArray(rows) ? rows.map((r) => r?.name).filter(Boolean) : null; } catch { return null; }
 }
 
 /**

package/lib/quoxon/slash/cliLeaves.json

@@ -458,12 +458,25 @@
 "lucid area":"read",
 "lucid ask":"read",
 "lucid blind":"write",
+"lucid brief":"read",
 "lucid deck":"never",
 "lucid do":"write",
 "lucid feeds":"read",
 "lucid forget":"write",
+"lucid goals add":"write",
+"lucid goals archive":"write",
+"lucid goals change":"write",
+"lucid goals confirm":"write",
+"lucid goals erase":"never",
+"lucid goals export":"write",
+"lucid goals history":"read",
+"lucid goals link":"write",
+"lucid goals restore":"never",
+"lucid goals show":"read",
 "lucid herald set":"write",
 "lucid herald test":"write",
+"lucid insights show":"read",
+"lucid insights status":"read",
 "lucid journal":"read",
 "lucid lessons":"read",
 "lucid replay":"read",
@@ -476,9 +489,12 @@
 "lucid why":"read",
 "mail account pin":"write",
 "mail accounts":"read",
+"mail block":"write",
+"mail blocked":"read",
 "mail connect":"never",
 "mail disconnect":"write",
 "mail import":"never",
+"mail junk":"write",
 "mail list":"read",
 "mail moves":"read",
 "mail proposals":"read",
@@ -487,12 +503,18 @@
 "mail resolve":"write",
 "mail sync":"write",
 "mail sync-status":"write",
+"mail trust":"write",
+"mail unblock":"write",
 "mail undo":"write",
 "mail watch active":"write",
 "mail watch add":"write",
 "mail watch list":"read",
 "mail watch rm":"write",
 "mail zones":"read",
+"mcp bundle":"never",
+"mcp token create":"never",
+"mcp token list":"read",
+"mcp token revoke":"write",
 "memory core":"read",
 "memory create":"write",
 "memory delete":"write",
@@ -546,8 +568,10 @@
 "mon wazuh triage":"read",
 "mon wazuh vulns":"read",
 "monitoring health":"read",
+"monitoring incidents claim":"write",
 "monitoring incidents get":"read",
 "monitoring incidents list":"read",
+"monitoring incidents status":"write",
 "motion":"write",
 "notes actions":"write",
 "notes append":"write",
@@ -578,11 +602,13 @@
 "notes schedule resume":"write",
 "notes schedule rm":"write",
 "notes scorecard":"write",
+"notes seal convert":"never",
 "notes seal edit":"never",
 "notes seal init":"write",
 "notes seal new":"write",
 "notes seal open":"never",
 "notes seal print":"write",
+"notes seal purge":"never",
 "notes seal status":"read",
 "notes search":"read",
 "notes settings list":"read",
@@ -606,6 +632,7 @@
 "objective list":"read",
 "objective retry":"write",
 "objective start":"write",
+"offload leases":"read",
 "offload release":"write",
 "offload status":"read",
 "onboard":"write",
@@ -627,15 +654,22 @@
 "org update":"write",
 "peek":"read",
 "plan add":"write",
+"plan brief":"read",
 "plan completed":"read",
 "plan focus":"read",
+"plan followup add":"write",
+"plan followup done":"write",
+"plan followup status":"write",
+"plan followups":"read",
 "plan list":"read",
 "plan move":"write",
 "plan note":"write",
 "plan phase":"write",
 "plan plan":"write",
 "plan rename":"write",
+"plan roadmap archive":"write",
 "plan roadmap create":"write",
+"plan roadmap unarchive":"write",
 "plan roadmaps":"read",
 "plan search":"read",
 "plan show":"read",
@@ -643,6 +677,7 @@
 "plan status":"write",
 "plan timeline":"read",
 "plan update":"write",
+"plan watch":"never",
 "plugin assign add":"write",
 "plugin assign list":"read",
 "plugin assign remove":"write",

package/lib/quoxon/slash/dashboard.js

@@ -10,6 +10,7 @@
  * on the dashboard home instead; nothing breaks.
  */
 import { spawn as nodeSpawn } from 'node:child_process';
+import { isWebPty } from '../webPty.js';
 
 /** Page name -> real route in src/config/routeRegistry.js (approvals = the HITL /inbox, inbox = InboxQ mail). */
 export const PAGES = {
@@ -40,6 +41,7 @@ export function openerFor(platform = process.platform) {
 
 /** -> { opened: true } | { opened: false, reason: 'ssh' | 'no-opener' | 'failed' }. Never throws, never uses a shell. */
 export function openInBrowser(url, { env = process.env, platform = process.platform, spawn = nodeSpawn } = {}) {
+  if (isWebPty(env)) return Promise.resolve({ opened: false, reason: 'no-opener' }); // QUOXON web PTY: the link is printed, nothing starts on the server
   if (isRemoteSession(env)) return Promise.resolve({ opened: false, reason: 'ssh' });
   const op = openerFor(platform);
   if (!op) return Promise.resolve({ opened: false, reason: 'no-opener' });

package/lib/quoxon/slash/listView.js

@@ -9,7 +9,7 @@ import { c, clip } from '../theme.js';
 
 const h = React.createElement;
 
-export function ListView({ title = null, rows = [], sel = 0, cols = 80, hint = null, empty = null, more = 0 }) {
+export function ListView({ title = null, rows = [], sel = 0, cols = 80, hint = null, empty = null, more = 0, notes = [] }) {
   // The key column grows with the window (22 cells minimum, 32 at most) and always leaves a one-cell gap, so a name that fits is shown whole;
   // one that does not gets the ellipsis from truncate-end, never a silent cut.
   const keyW = Math.min(Math.max(22, Math.min(32, Math.floor(cols / 3))), Math.max(8, ...rows.map(r => [...String(r.key || '')].length)) + 1);
@@ -26,5 +26,6 @@ export function ListView({ title = null, rows = [], sel = 0, cols = 80, hint = n
         h(Text, { color: c(r.dim ? 'muted' : 'text'), wrap: 'truncate-end' }, clip(String(body || ''), textW)));
     }),
     more > 0 ? h(Text, { color: c('muted') }, `  … ${more} more, keep typing to narrow`) : null,
+    ...(notes || []).map((n, i) => h(Text, { key: `note:${i}`, color: c('muted'), wrap: 'truncate-end' }, `  ${clip(n, cols - 4)}`)), // never selectable: no marker, not in rows
     hint ? h(Text, { color: c('dim') }, `  ${clip(hint, cols - 4)}`) : null);
 }

package/lib/quoxon/slash/palette.js

@@ -109,6 +109,23 @@ export function filterPalette(items, query) {
   return scored.sort((a, b) => a.best - b.best || a.idx - b.idx).map(x => x.it);
 }
 
+/**
+ * A match too loose to pre-highlight: not a prefix of the name or an alias, and not a description word that starts
+ * with a 2+ letter query. "/y" -> /hyperion (a letter inside the name) is weak; "/one" -> /approvals ("one at a time")
+ * is not. A weak top row is shown without the marker until the user moves the selection.
+ */
+const isSubsequence = (q, s) => { let i = 0; for (const ch of s) if (ch === q[i]) i++; return i === q.length; };
+
+export function weakMatch(query, it) {
+  const q = String(query ?? '').toLowerCase();
+  if (!q || !it) return false;
+  if ([it.id, ...(it.aliases || []).map(a => a.slice(1))].some(n => String(n).toLowerCase().startsWith(q))) return false;
+  // A 3+ letter abbreviation of the name ("/aprvl" -> /approvals) is deliberate, not a stray letter inside it.
+  if (q.length >= 3 && isSubsequence(q, String(it.id).toLowerCase())) return false;
+  const long = String(it.longDesc || it.desc || '').toLowerCase();
+  return !(q.length >= 2 && new RegExp('(^|[^a-z0-9])' + q.replace(/[^a-z0-9]/g, '\\$&')).test(long));
+}
+
 /** Bulk or destructive commands: never offered (so never pre-highlighted) by a loose query (owner 2026-10-26: Enter on "/" approved everything). */
 export const GUARDED_IDS = new Set(['yestoall', 'approve', 'deny']);
 
@@ -123,6 +140,30 @@ export function guardBulk(list, query) {
   return list.filter(it => !GUARDED_IDS.has(it.id) || names(it).includes(q) || (q.length >= 3 && !shared && names(it).some(n => n.startsWith(q))));
 }
 
+/**
+ * The guarded commands a loose query hid, so the palette can say why they are missing instead of leaving a weak
+ * fuzzy hit on top (owner 2026-11-05: "/y" showed /hyperion). Only names that START with the query count, and only
+ * for a non-empty query (a bare "/" stays quiet). `reach` is the shortest input that makes it the unique match.
+ * These are notes, never rows: the guard still decides what can be selected.
+ */
+export function guardedHints(items, query) {
+  const q = String(query ?? '').toLowerCase();
+  if (!q) return [];
+  const shown = (p) => guardBulk(filterPalette(items, p), p).map(i => i.id);
+  const now = shown(q);
+  const out = [];
+  for (const it of items) {
+    if (!GUARDED_IDS.has(it.id) || it.planned || now.includes(it.id) || !it.id.startsWith(q)) continue;
+    let reach = it.name;
+    for (let n = Math.max(3, q.length + 1); n < it.id.length; n++) {
+      const p = it.id.slice(0, n);
+      if (shown(p).includes(it.id)) { reach = '/' + p; break; }
+    }
+    out.push({ name: it.name, reach });
+  }
+  return out;
+}
+
 /** What Tab puts in the draft: the name, plus a space when the command takes arguments. */
 export function completion(item) {
   const takesArgs = /^\S+\s+\S/.test(String(item.usage).trim());

package/lib/quoxon/slash/paletteController.js

@@ -5,7 +5,7 @@
  */
 import { findEntry } from '../commands.js';
 import { signedOutNotice } from '../sessionDead.js';
-import { paletteQuery, paletteItems, filterPalette, guardBulk, completion, paletteView, PALETTE_MAX } from './palette.js';
+import { paletteQuery, paletteItems, filterPalette, guardBulk, guardedHints, weakMatch, completion, paletteView, PALETTE_MAX } from './palette.js';
 import { argContext, levelFor, staticItems, rankArgs, applyArg } from './args.js';
 import { mentionContext, rankMentions, applyMention } from '../mentions.js';
 
@@ -79,6 +79,8 @@ export function createPalette({
     if (q !== st.q) { st.q = q; st.sel = 0; st.picked = false; }
     return q === null ? [] : guardBulk(filterPalette(paletteItems(ctx()), q), q);
   };
+  /** The top row is only a weak match (weakMatch) and the user has not moved the selection: it is not highlighted. */
+  const weakTop = (list) => !st.picked && list.length > 0 && weakMatch(st.q, list[0]);
   const isOpen = () => {
     const d = getDraft();
     if (st.hold !== null) { // a command was just submitted: closed until the draft is genuinely edited (owner 2026-10-27: a stale palette ran /sleep)
@@ -162,9 +164,11 @@ export function createPalette({
     }
     const list = rows();
     const v = paletteView(list, st.sel, PALETTE_MAX);
+    const q = paletteQuery(getDraft());
+    const notes = guardedHints(paletteItems(ctx()), q).map(g => `${g.name} is held back so a stray Enter cannot run it: type ${g.reach} to reach it`);
     return {
       rows: v.rows.map(it => ({ key: it.name, text: (it.aliases.length ? `(also ${it.aliases.join(', ')}) ` : '') + it.desc, dim: Boolean(it.disabled), note: it.disabled || null })),
-      sel: v.sel, more: v.more,
+      sel: weakTop(list) ? -1 : v.sel, more: v.more, notes,
       empty: 'No command matches. Enter sends it anyway; /help lists everything.',
       hint: '↑↓ select · Tab complete · Enter run · Esc close'
     };

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)), '..', '..', '..');
@@ -205,6 +206,7 @@ export function restartPlan({ argv, conversationId, profile = null, name = null,
  * 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, 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 });

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) : '';
@@ -127,7 +131,7 @@ export function withSenderSlot(rows, 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

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/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/whatsnew.jsonl

@@ -168,3 +168,9 @@
 {"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."}