quoxcli 0.4.0 → 0.6.0

package/lib/quoxon/gripeQueue.js

@@ -0,0 +1,135 @@
+/**
+ * GRIPE-QUEUE: a gripe that could not be filed because Quox did not answer (timeout, network, 5xx) is kept on disk and
+ * retried, never lost. Local only (~/.quox/gripe-queue.json, mode 0600). Each entry carries an idempotency key
+ * (sha256 of the normalised text + the UTC day) that rides on the filing request, so the collector can return the
+ * issue it already made when a request that timed out had in fact succeeded.
+ */
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import { redactSecrets } from './secretShape.js';
+
+export const RETRY_MIN_MS = 2 * 60 * 1000;
+export const GIVE_UP_MS = 24 * 60 * 60 * 1000;
+export const RECENT_FILED_CAP = 20;
+export const defaultQueuePath = (home = homedir()) => join(home, '.quox', 'gripe-queue.json');
+
+const normalise = (t) => String(t || '').trim().replace(/\s+/g, ' ').toLowerCase();
+/** sha256(normalised text + UTC day) -> hex. The same gripe retyped the same day maps to one key. */
+export function gripeKey(text, now = Date.now()) {
+  return createHash('sha256').update(`${normalise(text)}|${new Date(now).toISOString().slice(0, 10)}`).digest('hex');
+}
+
+/** A failure worth queueing: no HTTP status (timeout, network, refused) or a 5xx. 4xx is the user's to fix. */
+export function isRetryable(err) {
+  const s = err?.status;
+  if (s == null) return true;
+  return Number(s) >= 500;
+}
+
+export function gripeQueue(path = defaultQueuePath(), { now = () => Date.now() } = {}) {
+  const read = () => {
+    try { const d = JSON.parse(readFileSync(path, 'utf8')); return Array.isArray(d?.items) ? d : { items: [], lastTry: 0 }; }
+    catch { return { items: [], lastTry: 0 }; }
+  };
+  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; }
+  };
+  const trim = (d) => { // keep every open item, and only the most recent filed/expired ones
+    const open = d.items.filter(i => i.status === 'queued');
+    const done = d.items.filter(i => i.status !== 'queued').slice(-RECENT_FILED_CAP);
+    d.items = [...done, ...open];
+    return d;
+  };
+  return {
+    key: (text) => gripeKey(text, now()),
+    list: () => read().items,
+    /** Add (or find) the queued entry for this gripe. -> the entry. */
+    enqueue({ text, repo = null, key }) {
+      const d = read();
+      const k = key || gripeKey(text, now());
+      let it = d.items.find(i => i.key === k);
+      if (!it) { it = { key: k, text: redactSecrets(String(text)), repo, created_at: new Date(now()).toISOString(), status: 'queued', tries: 0 }; d.items.push(it); }
+      else if (it.status === 'expired') { it.status = 'queued'; }
+      write(trim(d));
+      return it;
+    },
+    /** Record a successful filing (from the live path or a retry) so /gripes can show the link. */
+    markFiled({ text, repo = null, key, url }) {
+      const d = read();
+      const k = key || gripeKey(text, now());
+      let it = d.items.find(i => i.key === k);
+      if (!it) { it = { key: k, text: redactSecrets(String(text)), repo, created_at: new Date(now()).toISOString(), tries: 0 }; d.items.push(it); }
+      Object.assign(it, { status: 'filed', url, filed_at: new Date(now()).toISOString() });
+      write(trim(d));
+      return it;
+    },
+    /**
+     * File what is queued, at most once per RETRY_MIN_MS across all callers, expiring entries older than 24 h.
+     * file(item) -> { filed:true, url } | { filed:false, retryable }. -> { ran, filed:[items], expired:[items], pending:n }.
+     */
+    async retry(file, { force = false } = {}) {
+      const d = read();
+      const t = now();
+      const expired = [];
+      for (const it of d.items) if (it.status === 'queued' && t - Date.parse(it.created_at) > GIVE_UP_MS) { it.status = 'expired'; expired.push(it); }
+      const open = d.items.filter(i => i.status === 'queued');
+      if (expired.length) write(d);
+      if (!open.length) return { ran: false, filed: [], expired, pending: 0 };
+      if (!force && t - (d.lastTry || 0) < RETRY_MIN_MS) return { ran: false, filed: [], expired, pending: open.length };
+      d.lastTry = t; write(d);
+      const filed = [];
+      for (const it of open) {
+        let r;
+        try { r = await file(it); } catch (e) { r = { filed: false, retryable: isRetryable(e) }; }
+        it.tries = (it.tries || 0) + 1;
+        if (r?.filed && r.url) { Object.assign(it, { status: 'filed', url: r.url, filed_at: new Date(now()).toISOString() }); filed.push(it); }
+        else if (r && r.retryable === false) { it.status = 'failed'; it.error = r.error || 'refused'; }
+        else break; // Quox still not answering: leave the rest for the next window
+      }
+      const fresh = read(); // another process may have enqueued meanwhile; merge by key
+      for (const it of d.items) { const j = fresh.items.findIndex(x => x.key === it.key); if (j >= 0) fresh.items[j] = it; else fresh.items.push(it); }
+      fresh.lastTry = d.lastTry;
+      write(trim(fresh));
+      return { ran: true, filed, expired, pending: fresh.items.filter(i => i.status === 'queued').length };
+    },
+  };
+}
+
+export const SAVED_LINE = "Saved; I'll file it when Quox answers again (/gripes shows the queue)";
+
+/**
+ * Run one live filing. run(key) -> { response, url, superseded, notes } (throws when Quox does not answer).
+ * A timeout, network or 5xx failure queues the gripe instead of losing it. -> { ok:true, ... } | { ok:false, queued, message }.
+ */
+export async function fileOrQueue({ text, repo = null, queue, run, queueable = true }) {
+  const key = queue.key(text);
+  try {
+    const r = await run(key);
+    if (r?.url) queue.markFiled({ text, repo, key, url: r.url });
+    return { ok: true, ...r };
+  } catch (e) {
+    const message = e?.status ? `HTTP ${e.status}: ${e.message}` : (e?.message || 'failed');
+    if (!queueable || !isRetryable(e)) return { ok: false, message };
+    queue.enqueue({ text, repo, key });
+    return { ok: false, queued: true, message, saved: SAVED_LINE };
+  }
+}
+
+/** The retry filer: straight to the governed proxy (no agent run), carrying the entry's key so a duplicate is impossible. */
+export function makeRetryFiler({ fileDeterministically, client, orgId }) {
+  return async (it) => {
+    const r = await fileDeterministically({
+      client, complaint: it.text, orgId: orgId || null, quiet: true, throwRetryable: true,
+      options: { yes: true, ...(it.repo ? { repo: it.repo } : {}), idempotencyKey: it.key },
+    });
+    return r.filed ? { filed: true, url: r.url } : { filed: false, retryable: false, error: r.error };
+  };
+}

package/lib/quoxon/inboxView.js

@@ -2,32 +2,80 @@
  * HITL-INBOX-BAR (owner 2026-10-26): the owner's Quox inbox in the chat. Pure helpers: the status-area bar text,
  * the arrival line, the /inbox table and the one-item view. No I/O here; app.js owns the calls.
  */
+import { bursts, burstLine } from './approvalBatch.js';
 const clip = (s, n) => { const t = String(s ?? '').replace(/\s+/g, ' ').trim(); return t.length > n ? `${t.slice(0, Math.max(0, n - 1))}…` : t; };
 const pad = (s, n) => { const t = clip(s, n); return t + ' '.repeat(Math.max(0, n - [...t].length)); };
 const ms = (v) => { const t = Date.parse(String(v ?? '').includes('T') || !v ? v : `${String(v).replace(' ', 'T')}Z`); return Number.isFinite(t) ? t : 0; };
-const CLOSED = new Set(['resolved', 'cancelled', 'expired', 'deleted', 'archived']);
+const CLOSED = new Set(['resolved', 'cancelled', 'expired', 'withdrawn', 'deleted', 'archived']);
 
 /** Newest first. */
 export const newestFirst = (items) => [...(Array.isArray(items) ? items : [])].filter((i) => i && i.id).sort((a, b) => ms(b.created_at ?? b.createdAt) - ms(a.created_at ?? a.createdAt));
 /** Unread = the server's per-user is_read flag is not set, and the item is not closed or archived. */
 export const isUnread = (it) => !it.is_read && !it.archived_at && !CLOSED.has(String(it.status || '').toLowerCase());
+/** Read but still open: what `/inbox unread all` flips back. */
+export const readItems = (items) => newestFirst(items).filter((i) => i.is_read && !i.archived_at && !CLOSED.has(String(i.status || '').toLowerCase()));
 export const unreadItems = (items) => newestFirst(items).filter(isUnread);
 
-/** The status-area line, or '' when nothing is unread: `📨 2 new · <newest title>`. */
-export function inboxBarText(items, cols = 80) {
-  const un = unreadItems(items);
+const titleOf = (it) => String(it.title || it.kind || 'untitled');
+const sameTitle = (a, b) => titleOf(a) === titleOf(b);
+
+/** Inbox noise (owner 2026-10-27). Mutes are { [source lowercase]: expiryEpochMs }, stored per profile in the CLI settings. */
+export const REPEAT_WINDOW_MS = 12 * 3600000;
+export const MUTE_DEFAULT_MS = 8 * 3600000;
+/** '30m' | '8h' | '1d' -> ms, or null when it is not a duration. */
+export function muteDuration(text) {
+  const m = /^(\d+)\s*(m|h|d)$/i.exec(String(text || '').trim());
+  if (!m || !Number(m[1])) return null;
+  return Number(m[1]) * { m: 60000, h: 3600000, d: 86400000 }[m[2].toLowerCase()];
+}
+/** The mutes that have not expired. */
+export function activeMutes(mutes, now = Date.now()) {
+  const out = {};
+  for (const [k, v] of Object.entries(mutes && typeof mutes === 'object' ? mutes : {})) if (Number(v) > now) out[String(k).toLowerCase()] = Number(v);
+  return out;
+}
+/** An approval is NEVER muted: approvals always announce. */
+export const isMuted = (it, mutes, now = Date.now()) => !isApprovalItem(it) && Boolean(activeMutes(mutes, now)[fromOf(it).toLowerCase()]);
+/** Decide which fresh arrivals print. `announced` is a Map(title -> { at, n }) kept for the window session and updated here. -> { print, collapsed, muted } */
+export function announceFresh(fresh, announced, { mutes = {}, now = Date.now() } = {}) {
+  const print = []; let collapsed = 0; let muted = 0;
+  for (const it of fresh) {
+    if (isMuted(it, mutes, now)) { muted++; continue; }
+    const key = titleOf(it); const prev = announced.get(key);
+    if (!isApprovalItem(it) && prev && now - prev.at < REPEAT_WINDOW_MS) { prev.n++; collapsed++; continue; }
+    announced.set(key, { at: now, n: 1 }); print.push(it);
+  }
+  return { print, collapsed, muted };
+}
+
+/** The status-area line, or '' when nothing is unread: `📨 2 new · <newest title> (×3)`. Muted sources are left out of the count. */
+export function inboxBarText(items, cols = 80, { mutes = {}, now = Date.now(), announced = null } = {}) {
+  const un = unreadItems(items).filter((i) => !isMuted(i, mutes, now));
   if (!un.length) return '';
   const head = `📨 ${un.length} new · `;
-  return head + clip(un[0].title || un[0].kind || 'untitled', Math.max(8, cols - 4 - [...head].length));
+  const burst = bursts(un).find((b) => b.items.includes(un[0])); // APPROVAL-BURST: a burst of one agent's same-tool approvals reads as one line
+  if (burst) return head + clip(burstLine(burst).replace(/^📨 /, '').replace(/ · \/approvals$/, ''), Math.max(8, cols - 4 - [...head].length));
+  const reps = Math.max(un.filter((i) => sameTitle(i, un[0])).length, announced?.get(titleOf(un[0]))?.n || 0);
+  const tail = reps > 1 ? ` (×${reps})` : '';
+  return head + clip(titleOf(un[0]), Math.max(8, cols - 4 - [...head].length - [...tail].length)) + tail;
 }
 
 /** Unread items not seen on an earlier poll. `seen` is a Set of ids; the first poll seeds it and announces nothing. */
 export function arrivals(items, seen) {
   const un = unreadItems(items);
   const fresh = seen ? un.filter((i) => !seen.has(i.id)) : [];
-  return { fresh, ids: new Set((Array.isArray(items) ? items : []).map((i) => i?.id).filter(Boolean)) };
+  // Cumulative: a short or empty read (collector restarting) or an item rolling out of the latest 10 must not make it "new" on return.
+  const ids = new Set(seen || []);
+  for (const i of Array.isArray(items) ? items : []) if (i?.id) ids.add(i.id);
+  return { fresh, ids };
 }
-export const arrivalLine = (it) => `📨 ${clip(it.title || it.kind || 'untitled', 70)} · /inbox 1`;
+export const SEEN_KEEP = 300;
+/** The persisted seen ids for one org (profile settings `inboxSeenByOrg`), or null when none were saved. */
+export const loadSeen = (settings, orgId) => { const v = settings?.inboxSeenByOrg?.[orgId || '_']; return Array.isArray(v) && v.length ? new Set(v) : null; };
+/** The settings value with this org's seen ids (newest kept, capped) stored. */
+export const withSeen = (settings, orgId, ids) => ({ ...(settings?.inboxSeenByOrg || {}), [orgId || '_']: [...ids].slice(-SEEN_KEEP) });
+/** One arrival line; `n` is the item's own number in the /inbox list (0 when it is not in the latest 10; defaults to 1). */
+export const arrivalLine = (it, n = 1) => `📨 ${clip(it.title || it.kind || 'untitled', 70)} · /inbox${n ? ` ${n}` : ''}`;
 
 export const fromOf = (it) => String(it.created_by_name || it.payload?.source || it.payload?.approval_context?.source_label || it.source || it.inbox_type || it.kind || 'system');
 export function ageOf(v, now = Date.now()) {
@@ -40,40 +88,95 @@ export function ageOf(v, now = Date.now()) {
 }
 
 /** The latest 10 as a compact table; unread rows carry a dot. -> [{ text, tone }] */
-export function inboxTable(items, now = Date.now(), cols = 100, max = 10) {
+export function inboxTable(items, now = Date.now(), cols = 100, max = 10, mutes = {}) {
   const rows = newestFirst(items).slice(0, max);
-  if (!rows.length) return [{ text: 'Your inbox is empty.', tone: 'dim' }];
+  if (!rows.length) return [{ text: 'Your inbox is empty. (email is /mail)', tone: 'dim' }];
   const tw = Math.max(16, Math.min(60, cols - 40));
   const out = [{ text: `  ${pad('#', 3)}${pad('when', 6)}${pad('from', 14)}${pad('title', tw)} state`, tone: 'dim' }];
   rows.forEach((it, i) => {
-    const un = isUnread(it);
-    out.push({ text: `${un ? '●' : ' '} ${pad(i + 1, 3)}${pad(ageOf(it.created_at ?? it.createdAt, now), 6)}${pad(fromOf(it), 14)}${pad(it.title || it.kind || 'untitled', tw)} ${un ? 'unread' : (it.status || 'read')}`, tone: un ? 'accent' : 'dim' });
+    const un = isUnread(it); const mu = isMuted(it, mutes, now);
+    const reps = un ? unreadItems(items).filter((x) => sameTitle(x, it)).length : 0;
+    const title = titleOf(it); const shown = reps > 1 ? `${clip(title, Math.max(8, tw - 6))} (×${reps})` : title;
+    out.push({ text: `${un ? '●' : ' '} ${pad(i + 1, 3)}${pad(ageOf(it.created_at ?? it.createdAt, now), 6)}${pad(fromOf(it), 14)}${pad(shown, tw)} ${un ? 'unread' : (it.status || 'read')}${mu ? ' (muted)' : ''}`, tone: un && !mu ? 'accent' : 'dim' });
   });
-  const un = unreadItems(items).length;
-  out.push({ text: `${un} unread · /inbox N open one · /inbox read N|all · /inbox open N (approvals)`, tone: 'dim' });
+  const un = unreadItems(items).filter((i) => !isMuted(i, mutes, now)).length;
+  out.push({ text: `${un} unread · /inbox N or /inbox show N reads one · /inbox read N|all marks · /inbox unread N|all · /inbox open N (approvals) · /inbox mute <from> [1h|8h|1d] · email is /mail`, tone: 'dim' });
   return out;
 }
 
-/** Arg grammar: '' | N | read N|all | open N. -> { kind, n?|all? } | { kind:'usage' } */
+/** '5 6', '5-8', '1,3', '#2 4-5' -> sorted unique numbers, or null when any token is not a number or range. */
+export function parseNumbers(text) {
+  const toks = String(text || '').trim().split(/[\s,]+/).filter(Boolean);
+  if (!toks.length) return null;
+  const out = new Set();
+  for (const t of toks) {
+    const m = /^#?(\d+)(?:-#?(\d+))?$/.exec(t); if (!m) return null;
+    const a = Number(m[1]), b = m[2] === undefined ? a : Number(m[2]);
+    if (a < 1 || b < 1 || b - a > 200) return null;
+    for (let k = Math.min(a, b); k <= Math.max(a, b); k++) out.add(k);
+  }
+  return [...out].sort((x, y) => x - y);
+}
+const one = (kind, ns) => (ns.length === 1 ? { kind, n: ns[0] } : { kind, ns });
+
+/** Arg grammar: '' | N | N open|read | read N..|all | open N. Several numbers and ranges (5 6, 5-8) are fine for read. -> { kind, n? | ns? | all? } | { kind:'usage' } */
 export function parseInbox(arg) {
   const a = String(arg || '').trim().toLowerCase();
   if (!a || a === 'list' || a === 'latest') return { kind: 'list' };
-  let m = /^(?:show\s+)?#?(\d+)$/.exec(a); if (m) return { kind: 'show', n: Number(m[1]) };
-  m = /^open\s+#?(\d+)$/.exec(a); if (m) return { kind: 'open', n: Number(m[1]) };
-  m = /^read\s+(all|#?\d+)$/.exec(a); if (m) return m[1] === 'all' ? { kind: 'read', all: true } : { kind: 'read', n: Number(m[1].replace('#', '')) };
+  if (a === 'mutes') return { kind: 'mutes' };
+  let m = /^(mute|unmute)\s+(\S+)(?:\s+(\S+))?$/.exec(a);
+  if (m) {
+    if (m[1] === 'unmute') return m[3] ? { kind: 'usage' } : { kind: 'unmute', source: m[2] };
+    const dur = m[3] === undefined ? MUTE_DEFAULT_MS : muteDuration(m[3]);
+    return dur ? { kind: 'mute', source: m[2], ms: dur } : { kind: 'usage' };
+  }
+  m = /^(?:(?:show|view)\s+)?#?(\d+)$/.exec(a); if (m) return { kind: 'show', n: Number(m[1]) };
+  m = /^(open|read|unread)\s+(.+)$/.exec(a);
+  if (m) {
+    if ((m[1] === 'read' || m[1] === 'unread') && m[2] === 'all') return { kind: m[1], all: true };
+    const ns = parseNumbers(m[2]); if (!ns) return { kind: 'usage' };
+    if (m[1] === 'open') return ns.length === 1 ? { kind: 'open', n: ns[0] } : { kind: 'usage' };
+    return one(m[1], ns);
+  }
+  m = /^(.+?)\s+(open|read|unread|show|view)$/.exec(a); // word order: /inbox 1 open, /inbox 5-8 read, /inbox 1 show
+  if (m) {
+    const ns = parseNumbers(m[1]); if (!ns) return { kind: 'usage' };
+    if (m[2] === 'open') return ns.length === 1 ? { kind: 'open', n: ns[0] } : { kind: 'usage' };
+    if (m[2] === 'show' || m[2] === 'view') return ns.length === 1 ? { kind: 'show', n: ns[0] } : { kind: 'usage' };
+    return one(m[2], ns);
+  }
   return { kind: 'usage' };
 }
-export const INBOX_USAGE = 'Usage: /inbox | /inbox N | /inbox read N|all | /inbox open N';
+export const INBOX_USAGE = 'Usage: /inbox | /inbox N or /inbox show N or /inbox N show (the whole item) | /inbox read N|N-M|all (marks read, does not show) | /inbox unread N|N-M|all (undo a read) | /inbox open N (an approval goes to /approvals; shows any other item) | /inbox mute <from> [1h|8h|1d] | /inbox unmute <from> | /inbox mutes (email is /mail)';
 
-/** One item in full. -> [{ text, tone }] */
-export function inboxDetail(it, now = Date.now()) {
+/** The first non-empty string among the item's own body fields and the payload's (body_md is the stored column every task/info item uses). */
+const bodyOf = (it) => {
   const p = it.payload || {};
-  const body = it.body || it.message || p.message || p.body || p.summary || p.text || '';
+  for (const v of [it.body_md, it.body, it.message, p.body_md, p.body, p.body_text, p.text, p.message, p.summary, p.description]) if (typeof v === 'string' && v.trim()) return v;
+  return '';
+};
+/** One item in full: sender, subject, the whole body (every line, nothing cut), then the actions that apply. `n` is its /inbox number. -> [{ text, tone }] */
+export function inboxDetail(it, now = Date.now(), n = 0) {
+  const p = it.payload || {};
+  const body = bodyOf(it);
+  const subject = p.subject || p.email_subject || '';
   const out = [{ text: `${it.title || it.kind || 'untitled'}`, tone: 'accent' },
-    { text: `from ${fromOf(it)} · ${ageOf(it.created_at ?? it.createdAt, now)} ago · ${it.kind || 'item'} · ${it.priority || 'normal'} · ${it.status || '?'}`, tone: 'dim' }];
+    { text: `from ${p.from || p.sender || p.from_email || fromOf(it)} · ${ageOf(it.created_at ?? it.createdAt, now)} ago · ${it.kind || 'item'} · ${it.priority || 'normal'} · ${it.status || '?'}`, tone: 'dim' }];
+  if (subject && subject !== it.title) out.push({ text: `subject: ${subject}`, tone: 'dim' });
   if (body) for (const l of String(body).split('\n')) out.push({ text: l, tone: 'text' });
+  else out.push({ text: '(no body: this item carries only a title)', tone: 'dim' });
   if (it.dashboard_url) out.push({ text: it.dashboard_url, tone: 'dim' });
+  const at = n ? ` ${n}` : ' N';
+  out.push({ text: `actions: /inbox unread${at} (keep it unread) · /inbox read${at} · /inbox${isApprovalItem(it) ? ` open${at} (decide it in /approvals)` : ''}`, tone: 'dim' });
   return out;
 }
 /** Approval-type items route to /approvals (the existing view). */
 export const isApprovalItem = (it) => String(it.kind || '').toLowerCase() === 'approval' || Boolean(it.payload?.approval_context) || it.payload?.type === 'decision';
+
+/** /inbox mutes -> [{ text, tone }] with each expiry. */
+export function mutesLines(mutes, now = Date.now()) {
+  const act = Object.entries(activeMutes(mutes, now));
+  if (!act.length) return [{ text: 'No sources muted. /inbox mute <from> [1h|8h|1d] (default 8h). Approvals are never muted.', tone: 'dim' }];
+  const left = (v) => { const m = Math.ceil((v - now) / 60000); return m < 90 ? `${m}m` : m < 2880 ? `${Math.round(m / 60)}h` : `${Math.round(m / 1440)}d`; };
+  return act.map(([k, v]) => ({ text: `${k} muted until ${new Date(v).toISOString().slice(0, 16).replace('T', ' ')} UTC (${left(v)} left)`, tone: 'dim' }));
+}

package/lib/quoxon/keys.js

@@ -53,7 +53,7 @@ const CSI_KEYS = {
   '\x1bOA': 'up', '\x1bOB': 'down', '\x1bOC': 'right', '\x1bOD': 'left',
   '\x1b[H': 'home', '\x1b[F': 'end', '\x1bOH': 'home', '\x1bOF': 'end',
   '\x1b[1~': 'home', '\x1b[4~': 'end', '\x1b[7~': 'home', '\x1b[8~': 'end',
-  '\x1b[3~': 'delete', '\x1b[Z': 'shift-tab',
+  '\x1b[3~': 'delete', '\x1b[5~': 'pageup', '\x1b[6~': 'pagedown', '\x1b[Z': 'shift-tab',
   '\x1b[13;2u': 'shift-enter', '\x1b[27;2;13~': 'shift-enter', '\x1b\r': 'shift-enter', '\x1b\n': 'shift-enter',
   '\x1b[1;5D': 'word-left', '\x1b[1;5C': 'word-right', '\x1b[1;3D': 'word-left', '\x1b[1;3C': 'word-right',
   // COMPOSER-EDIT (owner 2026-10-17: edit like Claude Code's prompt box). Alt+B/F (macOS Option+Left/Right), iTerm2 Alt+arrows,
@@ -69,7 +69,7 @@ const CSI_LIST = Object.keys(CSI_KEYS).sort((a, b) => b.length - a.length);
 
 const CTRL = {
   '\x01': 'home', '\x05': 'end', '\x03': 'ctrl-c', '\x04': 'ctrl-d', '\x07': 'ctrl-g', '\x12': 'ctrl-r',
-  '\x0b': 'kill-line-forward', '\x0f': 'ctrl-o', '\x13': 'ctrl-s', '\x15': 'kill-line', '\x17': 'delete-word',
+  '\x0b': 'kill-line-forward', '\x0f': 'ctrl-o', '\x13': 'ctrl-s', '\x1d': 'ctrl-]', '\x15': 'kill-line', '\x17': 'delete-word',
   '\x1f': 'undo', '\x19': 'redo', '\x0a': 'newline', '\x7f': 'backspace', '\x08': 'backspace',
   '\r': 'enter', '\t': 'tab', '\x02': 'left', '\x06': 'right'
 };

package/lib/quoxon/launcher.js

@@ -18,6 +18,7 @@ import { spawn } from 'node:child_process';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir, constants as osConstants } from 'node:os';
 import { join } from 'node:path';
+import { isWebPty } from './webPty.js';
 
 /** The client asks its launcher for a restart with this exit code AND a handoff file (both, never one alone). */
 export const RESTART_EXIT_CODE = 75;
@@ -46,7 +47,7 @@ export function resetLauncherHandoff() { handoff = undefined; }
 
 /** Should this invocation become the launcher? Only an interactive client on a real terminal, never a launched child. */
 export function shouldLaunch({ argv = [], env = process.env, isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
-  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1') return false;
+  if (!isTTY || env[LAUNCHER_HANDOFF_ENV] || env[NO_LAUNCHER_ENV] === '1' || isWebPty(env)) return false;
   const head = argv.indexOf('--') === -1 ? argv : argv.slice(0, argv.indexOf('--'));
   return !head.some(a => a === '--print' || a.startsWith('--print=') || a === '-h' || a === '--help');
 }

package/lib/quoxon/loopCard.js

@@ -16,6 +16,7 @@
  */
 import { graphemes } from './textBuffer.js';
 import { cellWidth } from './cells.js';
+import { stripForeignAnsi } from './foreignText.js';
 
 /** Below this width the card is one line (the full title is printed once in chat when the loop starts). */
 export const NARROW_COLS = 60;
@@ -39,7 +40,7 @@ const SPIN = ['◐', '◓', '◑', '◒'];
 
 /* ---- text helpers --------------------------------------------------------------------------- */
 
-const oneLine = (s) => String(s ?? '').replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '').replace(/\r/g, '');
+const oneLine = (s) => stripForeignAnsi(s).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, '').replace(/\r/g, '');
 const width = (s) => cellWidth(s);
 
 /** Wrap at spaces; a token longer than the line is broken by cells, never dropped. Keeps blank lines. */
@@ -328,6 +329,7 @@ function stripCells(st, frame) {
 const pulseRole = (st, frame) => (st.done || frame % 4 < 2 ? 'brand' : 'sky'); // the ∞ breathes while the loop runs and holds still once it is over
 
 function headStatus(st, now, frame) {
+  if (st.refused) return [R('✖ ', 'error'), R("can't open this loop", 'error')];
   const elapsed = st.startedAt != null ? fmtElapsed((st.finishedAt ?? now) - st.startedAt) : null;
   const turn = `turn ${(st.iteration ?? st.turn) || 0}${st.maxTurns ? `/${st.maxTurns}` : ''}`;
   if (st.done) {
@@ -406,7 +408,10 @@ export function cardLines(st, { cols = 80, now = Date.now(), frame = 0, expanded
   if (st.approval) for (const l of wrapText(`waiting for you: ${st.approval.what}. Open your approvals to answer.`, w - 2)) lines.push([R('⚠ ', 'warn'), R(l, 'warn')]);
   if (st.stall && !st.done) for (const l of wrapText(st.stall.text || 'no turn progress', w - 2)) lines.push([R('⚠ ', 'warn'), R(l, 'warn')]);
   if (st.conn === 'reconnecting') lines.push([R('◐ ', 'sky'), R(`stream dropped, reconnecting (attempt ${st.connAttempt})`, 'warn')]);
-  if (st.conn === 'lost') for (const l of wrapText(`lost the live stream${st.connNote ? `: ${st.connNote}` : ''}. The loop itself may still be running: quox loop status ${st.id}`, w - 2)) lines.push([R('✖ ', 'error'), R(l, 'error')]);
+  if (st.refused) for (const l of wrapText(`${st.refused}.`, w - 2)) lines.push([R('✖ ', 'error'), R(l, 'error')]);
+  else if (st.conn === 'quiet') lines.push([R('⚠ ', 'warn'), R(`no news from this loop for ${st.connNote} · the runner may be stuck · /loop status ${st.id}`, 'warn')]);
+  else if (st.conn === 'silent') for (const l of wrapText(String(st.connNote || ''), w - 2)) lines.push([R('⚠ ', 'warn'), R(l, 'warn')]);
+  else if (st.conn === 'lost') for (const l of wrapText(`lost the live stream${st.connNote ? `: ${st.connNote}` : ''}. The loop itself may still be running: quox loop status ${st.id}`, w - 2)) lines.push([R('✖ ', 'error'), R(l, 'error')]);
   if (st.done && st.reason && st.state !== 'completed') for (const l of wrapText(`reason: ${humanReason(st.reason)}`, w - 2)) lines.push([R('  ', 'text'), R(l, FINAL[st.state]?.role || 'text')]);
 
   // spool

package/lib/quoxon/loopCards.js

@@ -27,7 +27,7 @@ export function createLoopCards({ api, say, addItem, bump, dragon = null, now =
   let focusId = null, cancelTick = null;
   const throttle = createThrottle(() => bump(), { minMs: () => (focusId ? REDRAW_MIN_MS : REDRAW_UNFOCUSED_MS), now, ...(throttleTimer ? { timer: throttleTimer } : {}) });
 
-  const running = () => [...cards.values()].some((c) => !c.state.done);
+  const running = () => [...cards.values()].some((c) => !c.state.done && !c.state.refused);
   /**
    * A runner loop's stream `turn` counts model messages; its own turn is the snapshot's `iteration`. Read it again when a turn moves
    * (at most every REFRESH_MIN_MS; a request inside the window is made by the next tick). -> a promise that settles when the read is over.
@@ -43,7 +43,7 @@ export function createLoopCards({ api, say, addItem, bump, dragon = null, now =
   function tick() { // elapsed time and the spinner move once per tick, never faster than the throttle allows
     if (!running()) { cancelTick?.(); cancelTick = null; return; }
     if (!focusId && ++tickN % TICK_UNFOCUSED_EVERY) return;
-    for (const c of cards.values()) if (!c.state.done) { c.frame = (c.frame + 1) % 4; if (c.refreshDue) refresh(c); }
+    for (const c of cards.values()) if (!c.state.done && !c.state.refused) { c.frame = (c.frame + 1) % 4; if (c.refreshDue) refresh(c); }
     throttle.poke();
   }
   const ensureTick = () => { if (!cancelTick && running()) cancelTick = setTick(tick, TICK_MS); };
@@ -74,16 +74,26 @@ export function createLoopCards({ api, say, addItem, bump, dragon = null, now =
     throttle.poke();
   }
 
+  // The start line is only true once the loop has answered: a refused watch never says "started".
+  function announceStart(c) {
+    if (c.startSaid || !c.announce) return;
+    c.startSaid = true; const l = startLine(c.state); say(l.text, l.tone);
+  }
+
   async function run(c) {
     const ctl = c.abort = new AbortController();
     try {
       const out = await watch({
         api, id: c.id, signal: ctl.signal, sleep,
-        onSnapshot: (snap) => { c.state = applySnapshot(c.state, snap); if (c.state.done) c.quiet = true; throttle.poke(); }, // the finish line waits for the replay: it needs the receipts
-        onEvent: (ev) => onEvent(c, ev),
+        onSnapshot: (snap) => { announceStart(c); c.state = applySnapshot(c.state, snap); if (c.state.done) c.quiet = true; throttle.poke(); }, // the finish line waits for the replay: it needs the receipts
+        onEvent: (ev) => { announceStart(c); onEvent(c, ev); },
         onConn: ({ conn, attempt, note }) => { if (!c.state.done) { c.state = setConn(c.state, conn, { attempt, note }); throttle.poke(); } },
       });
-      if (out?.lost && !c.state.done) { c.state = setConn(c.state, 'lost', { attempt: 0, note: out.reason }); }
+      if (out?.lost && !c.state.done) {
+        c.state = setConn(c.state, 'lost', { attempt: 0, note: out.reason });
+        // Refused (403 / 404) before a single event: the loop is not this caller's (or does not exist). Say so; it never started for us.
+        if ((out.status === 403 || out.status === 404) && c.state.startedAt == null && !c.state.turn && !c.startSaid) c.state = { ...c.state, refused: "that loop belongs to another workspace (or doesn't exist)" };
+      }
       if (c.state.done && !c.finishedSaid && !c.finishing) { c.finishedSaid = true; for (const l of finishLines(c.state)) say(l.text, l.tone); } // finished before we looked (or the replay ended without a finish event)
     } catch (e) {
       c.state = setConn(c.state, 'lost', { note: e?.message || 'failed' });
@@ -95,9 +105,8 @@ export function createLoopCards({ api, say, addItem, bump, dragon = null, now =
     watch(id, { title = '', agent = null, announce = true } = {}) {
       if (!id) return null;
       if (cards.has(id)) return cards.get(id);
-      const c = { id, state: initLoop({ id, title, agent }), expanded: false, focused: false, confirm: false, frame: 0, abort: null, finishedSaid: false };
+      const c = { id, state: initLoop({ id, title, agent }), expanded: false, focused: false, confirm: false, frame: 0, abort: null, finishedSaid: false, startSaid: false, announce };
       cards.set(id, c);
-      if (announce) { const l = startLine(c.state); say(l.text, l.tone); } // the start line first, then the card, then the story beneath
       addItem({ id: `loopcard-${id}`, kind: 'loopcard', card: c });
       ensureTick();
       run(c).then(() => bump());
@@ -130,7 +139,7 @@ export function createLoopCards({ api, say, addItem, bump, dragon = null, now =
     get: (id) => cards.get(id) || null,
     all: () => [...cards.values()],
     /** True while this history item must stay in the live region (commitLimit): its loop has not finished. */
-    held: (item) => Boolean(item?.kind === 'loopcard' && item.card && (!item.card.state.done || item.card.focused)), // a focused card stays live even when finished, so Enter / Esc work on it
+    held: (item) => Boolean(item?.kind === 'loopcard' && item.card && ((!item.card.state.done && !item.card.state.refused) || item.card.focused)), // a focused card stays live even when finished, so Enter / Esc work on it
     anyRunning: running,
     /** The cards drawn above the composer: running ones, and a finished one you are still on. */
     pinned: () => [...cards.values()].filter(loopPinned),

package/lib/quoxon/loopStream.js

@@ -10,6 +10,7 @@
 export const BACKOFF_START_MS = 500;
 export const BACKOFF_CAP_MS = 10000;
 export const MAX_FAILS = 8;
+export const QUIET_START_MS = 2000, QUIET_CAP_MS = 60000, QUIET_AFTER = 10, QUIET_RETIRE_AFTER = 20; // (retire: the snapshot still says running after this many empty closes in a row -> stop watching) // empty-close reconnects while the snapshot says running
 const FATAL = new Set([401, 403, 404]);
 const TERMINAL_STATES = new Set(['completed', 'completed_with_errors', 'failed', 'interrupted', 'halted', 'cancelled', 'aborted', 'stopped']);
 const isTerminal = (snap) => Boolean(snap && (snap.finished === true || TERMINAL_STATES.has(snap.state)));
@@ -28,11 +29,12 @@ const sleepFor = (ms, signal) => new Promise((resolve) => {
  * handlers: { onSnapshot(snap), onEvent(ev), onConn({ conn: 'live'|'reconnecting'|'lost', attempt, note }) }
  * -> { finished: boolean, lost: boolean, lastSeq, reason? }
  */
-export async function watchLoop({ api, id, signal, since = 0, onSnapshot = () => {}, onEvent = () => {}, onConn = () => {}, sleep = sleepFor, backoffStart = BACKOFF_START_MS, backoffCap = BACKOFF_CAP_MS, maxFails = MAX_FAILS }) {
+export async function watchLoop({ api, id, signal, since = 0, onSnapshot = () => {}, onEvent = () => {}, onConn = () => {}, sleep = sleepFor, backoffStart = BACKOFF_START_MS, backoffCap = BACKOFF_CAP_MS, maxFails = MAX_FAILS, quietStart = QUIET_START_MS, quietCap = QUIET_CAP_MS, quietAfter = QUIET_AFTER, quietRetireAfter = QUIET_RETIRE_AFTER, now = Date.now }) {
+  let quietRuns = 0, quietSince = 0, quietSaid = false;
   let lastSeq = Number(since) || 0, fails = 0, delay = backoffStart, finished = false;
   try { onSnapshot(await api.loopSnapshot(id)); }
   catch (e) { // the snapshot is a head start, not a gate: the replayed events carry the same facts. A fatal status still stops.
-    if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: 0, note: describe(e) }); return { finished: false, lost: true, lastSeq, reason: describe(e) }; }
+    if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: 0, note: describe(e) }); return { finished: false, lost: true, lastSeq, status: e?.status, reason: describe(e) }; }
   }
   while (!signal?.aborted && !finished) {
     let sawEvent = false;
@@ -43,7 +45,7 @@ export async function watchLoop({ api, id, signal, since = 0, onSnapshot = () =>
         const seq = Number(ev.event_seq);
         if (Number.isFinite(seq) && seq <= lastSeq) continue; // the boundary event of a resume
         if (Number.isFinite(seq)) lastSeq = seq;
-        if (!sawEvent) { sawEvent = true; fails = 0; delay = backoffStart; onConn({ conn: 'live', attempt: 0, note: null }); }
+        if (!sawEvent) { sawEvent = true; fails = 0; quietRuns = 0; quietSaid = false; delay = backoffStart; onConn({ conn: 'live', attempt: 0, note: null }); }
         onEvent(ev);
         if (ev.type === 'loop.finished') { finished = true; break; }
       }
@@ -54,24 +56,32 @@ export async function watchLoop({ api, id, signal, since = 0, onSnapshot = () =>
         let snap = null;
         try { snap = await api.loopSnapshot(id); }
         catch (e) {
-          if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, reason: describe(e) }; }
+          if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, status: e?.status, reason: describe(e) }; }
           fails += 1;
-          if (fails >= maxFails) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, reason: describe(e) }; }
+          if (fails >= maxFails) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, status: e?.status, reason: describe(e) }; }
           onConn({ conn: 'reconnecting', attempt: fails, note: describe(e) });
           await sleep(delay, signal); delay = Math.min(delay * 2, backoffCap);
           continue;
         }
         if (isTerminal(snap)) { onSnapshot(snap); return { finished: true, lost: false, lastSeq, final: snap }; }
-        fails = 0; // still running: quiet, not a failure
-        await sleep(backoffStart, signal);
+        fails = 0; // still running: quiet, not a failure, but counted: capped backoff, and one honest line after quietAfter
+        if (quietRuns === 0) quietSince = now();
+        quietRuns += 1;
+        if (quietRuns >= quietRetireAfter) { // retirement: the snapshot (just re-read) still says running but nothing streams. Stop, say so plainly, never spin.
+          const reason = `the loop says running but its stream is silent; /loop ${id} to check, or it may have ended`;
+          onConn({ conn: 'silent', attempt: quietRuns, note: reason });
+          return { finished: false, lost: false, silent: true, lastSeq, reason };
+        }
+        if (quietRuns >= quietAfter && !quietSaid) { quietSaid = true; onConn({ conn: 'quiet', attempt: quietRuns, note: fmtDur(now() - quietSince) }); }
+        await sleep(Math.min(quietStart * 2 ** (quietRuns - 1), quietCap), signal);
         continue;
       }
       else if (!finished && sawEvent) fails = 0;
     } catch (e) {
       if (signal?.aborted) break;
-      if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, reason: describe(e) }; }
+      if (FATAL.has(e?.status)) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, status: e?.status, reason: describe(e) }; }
       fails += 1;
-      if (fails >= maxFails) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, reason: describe(e) }; }
+      if (fails >= maxFails) { onConn({ conn: 'lost', attempt: fails, note: describe(e) }); return { finished: false, lost: true, lastSeq, status: e?.status, reason: describe(e) }; }
       onConn({ conn: 'reconnecting', attempt: fails, note: describe(e) });
       await sleep(delay, signal); delay = Math.min(delay * 2, backoffCap);
       continue;
@@ -84,4 +94,5 @@ export async function watchLoop({ api, id, signal, since = 0, onSnapshot = () =>
   return { finished, lost: false, lastSeq };
 }
 
+const fmtDur = (ms) => { const m = Math.round(ms / 60000); return m >= 1 ? `${m} min` : `${Math.round(ms / 1000)}s`; };
 const describe = (e) => `${e?.status ? `HTTP ${e.status} ` : ''}${e?.message || 'failed'}`.trim();