quoxcli 0.3.1 → 0.5.0

package/lib/quoxon/roster.js

@@ -5,10 +5,11 @@
  * nothing (never a placeholder row).
  */
 import { clip } from './theme.js';
+import { humanReason, wrapText } from './loopCard.js';
 
 export const GLYPH = { running: '◐', waiting: '⏸', done: '✔', failed: '✖' };
 /** A row that ended without finishing says HOW: failed is the only error; the rest are neutral (no error colour). */
-export const OUTCOME_GLYPH = { failed: '✖', cancelled: '○', expired: '○', rejected: '⊘' };
+export const OUTCOME_GLYPH = { failed: '✖', halted: '⚠', cancelled: '○', expired: '○', rejected: '⊘' };
 export const FRESH_MS = 10 * 60 * 1000;      // finished rows linger this long
 export const USER_DONE_MS = 20 * 1000;       // a user-started completion vanishes quickly: rows come and go
 export const PENDING_FRESH_MS = 24 * 3600 * 1000; // an older "pending" is stale, not waiting
@@ -42,13 +43,17 @@ const FAILED = new Set(['failed', 'error', 'halted', 'cancelled', 'canceled', 't
 /** The word for how an ended row ended (state stays 'failed' for the ended-badly group; this says which). */
 export function outcomeOf(status) {
   const st = String(status || '').toLowerCase();
+  if (st === 'halted') return 'halted';
   if (st === 'cancelled' || st === 'canceled') return 'cancelled';
   if (st === 'expired') return 'expired';
   if (st === 'rejected') return 'rejected';
   return 'failed';
 }
 /** Word, glyph and whether it is an error, for a row. Non-failed states return their own state. */
-export function endWord(r) { return r.state === 'failed' ? outcomeOf(r.status) : r.state; }
+export function endWord(r) { return r.state === 'failed' ? (r.outcome || outcomeOf(r.status)) : r.state; }
+/** A human-halted loop keeps objective status 'failed'; the server says loop_state 'halted' (older servers: the halt text). */
+const HALT_TEXT = /^Loop (?:halted on demand|stopped by human review)/i;
+const isHaltedLoop = (o) => o.execution_mode === 'loop' && (o.loop_state === 'halted' || String(o.status || '').toLowerCase() === 'halted' || (String(o.status || '').toLowerCase() === 'failed' && HALT_TEXT.test(String(o.error_message || ''))));
 export const glyphOf = (r) => (r.state === 'failed' ? OUTCOME_GLYPH[endWord(r)] : GLYPH[r.state]);
 
 /** How long a finished row lingers before it leaves the roster (null while running/waiting). */
@@ -83,18 +88,22 @@ export function fromObjective(o, now = Date.now()) {
   if (!state) return null;
   const loop = o.execution_mode === 'loop';
   let activity = '';
-  if (state === 'failed' && o.error_message) activity = String(o.error_message);
+  const haltedLoop = state === 'failed' && isHaltedLoop(o);
+  // a halted loop reads its clean sentence (the server's loop_reason, with the person's name), never the raw record text
+  const shownError = !haltedLoop ? o.error_message : (o.loop_reason || ((n) => (n ? `Stopped by ${n[1].trim()}` : 'Halted on demand'))(/^Loop halted on demand by \S+ \(([^)]{1,80})\)/i.exec(String(o.error_message || ''))));
+  if (state === 'failed' && shownError) activity = humanReason(shownError); // the sentence whole, minus the raw spawner prefix; the view decides how to show it
+  else if (loop && state === 'done') activity = o.iteration_count > 0 ? `${o.iteration_count} turn${o.iteration_count === 1 ? '' : 's'}` : ''; // the row prints "done <age>" itself; a stale "iter 0/5" beside it was the lie
   else if (loop && o.max_iterations) activity = `iter ${o.iteration_count || 0}/${o.max_iterations}`;
   else if (o.task_count) activity = `${o.tasks_completed || 0}/${o.task_count} tasks`;
   else if (state === 'waiting') activity = 'waiting to start';
   const from = startedAt ?? createdAt;
   return {
     key: `objective:${o.id}`, id: o.id, source: 'objectives', background: false, kind: loop ? 'loop' : 'objective', state,
-    name: o.title || o.id, activity, status: o.status,
+    name: o.title || o.id, activity, status: o.status, ...(haltedLoop ? { outcome: 'halted' } : {}),
     startedAt: from, finishedAt, ageMs: from != null ? (state === 'done' || state === 'failed' ? (finishedAt ?? now) - from : now - from) : null,
     expiryMs: expiryFor(state, USER_DONE_MS),
     progressAt: latest(parseTime(o.updated_at), parseTime(o.last_progress_at), parseTime(o.last_heartbeat_at)),
-    detail: { description: o.description, error: o.error_message, tokens: o.tokens_used, toolCalls: o.tool_calls_used }
+    detail: { description: o.description, error: shownError ? humanReason(shownError) : shownError, tokens: o.tokens_used, toolCalls: o.tool_calls_used }
   };
 }
 
@@ -235,7 +244,7 @@ export function countsLine(rows) {
   const n = (s) => rows.filter(r => r.state === s).length;
   const o = (w) => rows.filter(r => r.state === 'failed' && endWord(r) === w).length;
   return [['running', 'running', n('running'), GLYPH.running], ['waiting', 'waiting', n('waiting'), GLYPH.waiting],
-    ['failed', 'failed', o('failed'), OUTCOME_GLYPH.failed], ['cancelled', 'cancelled', o('cancelled'), OUTCOME_GLYPH.cancelled],
+    ['failed', 'failed', o('failed'), OUTCOME_GLYPH.failed], ['halted', 'halted', o('halted'), OUTCOME_GLYPH.halted], ['cancelled', 'cancelled', o('cancelled'), OUTCOME_GLYPH.cancelled],
     ['expired', 'expired', o('expired'), OUTCOME_GLYPH.expired], ['rejected', 'rejected', o('rejected'), OUTCOME_GLYPH.rejected], ['done', 'finished', n('done'), GLYPH.done]]
     .filter(([, , k]) => k).map(([, w, k, g]) => `${g} ${k} ${w}`).join(' · ');
 }
@@ -249,46 +258,56 @@ export function countsLine(rows) {
  * one row each plus a summary line (owner, live 05:29): the bottom area must never grow with the inbox. A single approval
  * keeps its own row. Focus (the user is walking the roster) shows the real rows so selection stays truthful.
  */
-export function collapseApprovals(rows, now = Date.now()) {
+export function collapseApprovals(rows, now = Date.now(), staleAt = null) {
   const aps = rows.filter(r => r.kind === 'approval' && r.state === 'waiting');
-  if (aps.length < 2) return rows;
+  if (aps.length < (staleAt ? 1 : 2)) return rows;
   const started = aps.map(r => r.startedAt).filter(x => x != null);
   const newest = aps.reduce((a, b) => ((b.startedAt ?? -Infinity) > (a.startedAt ?? -Infinity) ? b : a));
   const one = { key: 'approval:*', id: '*', source: 'approvals', kind: 'approval', state: 'waiting', background: false, collapsed: true, count: aps.length,
     name: `${aps.length} approvals waiting`, activity: '/approvals', status: 'pending', startedAt: started.length ? Math.min(...started) : null, finishedAt: null,
-    oldestMs: started.length ? now - Math.min(...started) : null, newestTitle: String(newest.detail?.description || newest.name || ''), detail: {} };
+    oldestMs: started.length ? now - Math.min(...started) : null, staleAt: staleAt || null, newestTitle: String(newest.detail?.description || newest.name || ''), detail: {} };
   let placed = false;
   return rows.flatMap(r => (aps.includes(r) ? (placed ? [] : (placed = true, [one])) : [r]));
 }
 
-export function rosterView({ rows, cols, termRows = 40, max = MAX_ROWS, on = true, sel = 0, focus = false, now = Date.now(), motion = false }) {
+const KIND_ICON = { loop: '∞', objective: '◎' }; // QuoxGlyph registry keys qloop / objective
+export const kindLabel = k => (KIND_ICON[k] ? `${KIND_ICON[k]} ${k}` : k);
+
+export function rosterView({ rows, cols, termRows = 40, max = MAX_ROWS, on = true, sel = 0, focus = false, now = Date.now(), motion = false, staleAt = null }) {
   if (!on || !rows.length) return { mode: 'hidden', lines: [], more: 0 };
-  if (!focus) rows = collapseApprovals(rows, now);
+  if (!focus || staleAt) rows = collapseApprovals(rows, now, staleAt); // signed out: the cached count is last-known, always one stale row
   if (cols < MIN_FULL_COLS || termRows < MIN_FULL_ROWS) {
     return { mode: 'summary', lines: [], more: 0, summary: clip(' ' + countsLine(rows) + ' · /roster', cols - 1) };
   }
   const shown = rows.slice(0, max);
   const ageW = Math.max(5, ...shown.map(r => [...ageText(r, now)].length));
-  let pos = 0;
-  const kindW = Math.min(9, Math.max(...shown.map(r => r.kind.length)));
+  let pos = 0, reasonShown = false;
+  const kindW = Math.min(11, Math.max(...shown.map(r => [...kindLabel(r.kind)].length)));
   const lines = shown.map((r, i) => {
     const el = ageText(r, now).padStart(ageW);
     const tone = toneName(r, pos, now); if (r.kind !== 'approval') pos++;
     const actW = Math.min(18, Math.max(0, ...shown.map(x => [...(x.activity || '')].length)));
-    const act = clip(r.activity || '', actW).padEnd(actW);
+    const longReason = r.state === 'failed' && [...(r.activity || '')].length > actW; // a reason is never cut: the column says "stopped", the sentence follows wrapped
+    const act = (longReason ? clip('stopped', actW) : clip(r.activity || '', actW)).padEnd(actW);
     const fixed = 1 + 1 + 1 + kindW + 1 + 1 + actW + 1 + ageW + 2; // pulse column (space + glyph); marker glyph kind name act elapsed
     const nameW = Math.max(8, cols - 2 - fixed - 1);
     const name = clip(r.name, nameW).padEnd(nameW);
     const marker = focus && i === sel ? '›' : ' ';
+    if (r.collapsed && r.staleAt) { // signed out: last-known count with its time, never worded as live (owner live 2026-10-27)
+      const d = new Date(r.staleAt), at = `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+      const text = clip(`${r.count} waiting as of ${at} · sign in to see more: /login`, cols - 4);
+      return { key: r.key, kind: 'approval', state: r.state, tone: 'dim', selected: false, marker: ' ', glyph: GLYPH[r.state], rest: ' ' + text, pulse: '', pulseRole: 'dim', pulseKind: 'none', text: ` ${GLYPH[r.state]} ${text}` };
+    }
     if (r.collapsed) { // one summary row: count, oldest age, newest title, where to go; clipped to the line
       const head = `${r.count} approvals waiting · oldest ${elapsed(r.oldestMs)} · newest: `, tail = ' · /approvals';
       const room = cols - 5 - [...head].length - [...tail].length;
       const text = room >= 12 ? `${head}${clip(r.newestTitle, room)}${tail}` : clip(`${r.count} approvals waiting · oldest ${elapsed(r.oldestMs)}${tail}`, cols - 4); // too narrow for a title
       return { key: r.key, kind: 'approval', state: r.state, tone: toneName(r, pos, now), selected: false, marker: ' ', glyph: GLYPH[r.state], rest: ' ' + text, pulse: '', pulseRole: 'dim', pulseKind: 'none', text: ` ${GLYPH[r.state]} ${text}` };
     }
-    const rest = `${r.kind.padEnd(kindW)} ${name} ${act} ${el}`;
+    const rest = `${kindLabel(r.kind).padEnd(kindW)} ${name} ${act} ${el}`;
     const p = pulseOf(r, now, { motion });
-    return { key: r.key, kind: r.kind, state: r.state, tone, selected: focus && i === sel, marker, glyph: glyphOf(r), glyphRole: r.state === 'failed' && endWord(r) !== 'failed' ? 'dim' : null, rest: ' ' + rest, pulse: ' ' + p.glyph, pulseRole: p.role, pulseKind: p.kind, text: `${marker}${glyphOf(r)} ${rest} ${p.glyph}` };
+    const extra = longReason && !reasonShown ? (reasonShown = true, wrapText(r.activity, Math.max(20, cols - 8))) : null; // spelled out for the newest stopped row only: the bar must not grow with every old failure
+    return { key: r.key, kind: r.kind, state: r.state, tone, extra, selected: focus && i === sel, marker, glyph: glyphOf(r), glyphRole: r.state === 'failed' && endWord(r) === 'halted' ? 'warn' : r.state === 'failed' && endWord(r) !== 'failed' ? 'dim' : null, rest: ' ' + rest, pulse: ' ' + p.glyph, pulseRole: p.role, pulseKind: p.kind, text: `${marker}${glyphOf(r)} ${rest} ${p.glyph}` };
   });
   return { mode: 'full', lines, more: Math.max(0, rows.length - shown.length) };
 }
@@ -302,6 +321,6 @@ export function peekLines(row, now = Date.now()) {
   if (d.description) out.push(`goal ${d.description}`);
   if (d.workflowId) out.push(`workflow ${d.workflowId}`);
   if (d.trigger) out.push(`trigger ${d.trigger}`);
-  if (d.error && row.state === 'failed') out.push(`error ${typeof d.error === 'string' ? d.error : JSON.stringify(d.error)}`);
+  if (d.error && row.state === 'failed') out.push(`error ${typeof d.error === 'string' ? humanReason(d.error) : JSON.stringify(d.error)}`);
   return out;
 }

package/lib/quoxon/rosterSessions.js

@@ -0,0 +1,44 @@
+/**
+ * /roster text for the two things that are not work rows: attached agents (org lease list) and this box's live
+ * `claude --resume` processes. Pure; the process list and the attach list are injected by the caller.
+ */
+
+const age = (sec) => {
+  const s = Math.max(0, Math.round(sec));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return `${Math.floor(s / 86400)}d`;
+};
+
+const sinceText = (iso, now) => {
+  const t = Date.parse(iso || '');
+  return Number.isNaN(t) ? '?' : age((now - t) / 1000);
+};
+
+/** attached agents -> one line each: agent, splinter, session, lease id, heartbeat age, expiry. */
+export function attachLines(items, now = Date.now()) {
+  if (!items || !items.length) return ['  attached agents: none'];
+  return items.map((a) => `  ${a.agent_id} ${a.splinter || 'S1'} · ${a.session_label || '(no label)'} · lease ${a.lease_id} · heartbeat ${sinceText(a.last_heartbeat_at, now)} ago · expires ${a.expires_at || '?'}`);
+}
+
+const where = (p) => (p.tmux ? `tmux ${p.tmux}` : `not in tmux${p.tty && p.tty !== '?' ? ` ${p.tty}` : ''}`);
+const one = (p) => `${p.pid} ${where(p)} ${age(p.ageSec || 0)}`;
+
+/** live claude processes -> lines, grouped by name case-insensitively; a name held more than once is flagged. */
+export function sessionLines(procs) {
+  if (!procs || !procs.length) return ["  this box's sessions: none"];
+  const groups = new Map();
+  for (const p of procs) {
+    const k = String(p.name).toLowerCase();
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k).push(p);
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    const name = g[0].name;
+    if (g.length === 1) out.push(`  ${name}: ${one(g[0])}`);
+    else out.push(`  ⚠ ${name} x${g.length}: ${g.map(one).join(', ')}`);
+  }
+  return out;
+}

package/lib/quoxon/rows.js

@@ -21,8 +21,11 @@ import { execFile } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { cellWidth } from './cells.js';
 
 export const MAX_ROWS = 3;
+/** Lines drawn above the status bar (a row can bring several with `lines`); the stored-row cap stays MAX_ROWS. */
+export const MAX_LINES = 4;
 export const FETCH_TIMEOUT_MS = 5000;
 /** url rows fetch from busy boxes (the proof board is ~400 KB): 15 s. cmd rows keep FETCH_TIMEOUT_MS. */
 export const URL_TIMEOUT_MS = 15000;
@@ -220,11 +223,55 @@ const trendText = (t) => {
   return '';
 };
 
+/* ---- cells (contract v1.1, TUI-QPE 2026-10-19) --------------------------------------------------
+ * A row may carry `cells`: [{ parts: [{ text, tone?, bold?, keep?, group? }], keep? }]. Each part has its own colour
+ * (a tone), so one row can say "70%" in amber and "▼12 broke" in red. `keep` says what goes first when the window is
+ * narrow: the lowest keep is dropped whole (a part, the parts sharing its group, or a cell; never half a word); no keep
+ * = never dropped. Rows with the same `grid` share one keep order and line their cells up in columns; `min_cols` hides
+ * a row in a narrower window.
+ */
+export const CELL_LIMITS = { cells: 6, parts: 12, text: 80 };
+const keepOf = (k) => (typeof k === 'number' && Number.isFinite(k) ? Math.max(0, Math.min(99, k)) : null);
+
+function parseCells(list, warnings) {
+  if (!Array.isArray(list)) { warnings.push('"cells" is a list of {parts: [{text, tone}]}; ignored.'); return []; }
+  const out = [];
+  for (const c of list.slice(0, CELL_LIMITS.cells)) {
+    const raw = Array.isArray(c?.parts) ? c.parts : typeof c?.text === 'string' ? [c] : null;
+    if (!raw) { warnings.push('A cell needs "parts" (or "text"); skipped.'); continue; }
+    const parts = [];
+    for (const p of raw.slice(0, CELL_LIMITS.parts)) {
+      // Keep edge spaces (a part's own joiner, " · reach 214/266"): clean the middle, not the ends.
+      const t = typeof p?.text === 'string' ? p.text : typeof p?.text === 'number' ? fmtNum(p.text) : '';
+      const lead = /^\s/.test(t) ? ' ' : ''; const trail = /\s$/.test(t) ? ' ' : '';
+      const body = cleanText(t, CELL_LIMITS.text);
+      if (!body) continue;
+      const part = { text: lead + body + trail };
+      if (p.tone !== undefined && p.tone !== null) {
+        if (STATUS_ROW_TONES.includes(p.tone)) { if (p.tone !== 'neutral') part.tone = p.tone; }
+        else warnings.push(`a part's "tone" is one of ${STATUS_ROW_TONES.join(', ')}; "${cleanText(p.tone, 16)}" shows as neutral.`);
+      }
+      if (p.bold === true) part.bold = true;
+      const k = keepOf(p.keep); if (k !== null) part.keep = k;
+      if (typeof p.group === 'string' && /^[A-Za-z0-9_-]{1,16}$/.test(p.group)) part.group = p.group; // parts that drop together
+      parts.push(part);
+    }
+    if (!parts.length) continue;
+    const cell = { parts };
+    const k = keepOf(c.keep); if (k !== null) cell.keep = k;
+    out.push(cell);
+  }
+  return out;
+}
+
+/** cells -> one plain line (screen context, /row list, a narrow fallback). */
+export const cellsText = (cells) => (cells || []).map((c) => c.parts.map((p) => p.text).join('').trim()).join(' │ ');
+
 /**
  * Parsed data -> { seg, warnings } | { error }. Lenient on read (an unknown tone shows neutral and is named
  * in warnings, so `quox rows test` can say so); strict on what it prints (everything passes cleanText).
  */
-export function parseStatusRow(d) {
+export function parseStatusRow(d, depth = 0) {
   if (!d || typeof d !== 'object' || Array.isArray(d)) return { error: 'A status row is a JSON object: {"text": "..."}.' };
   const warnings = [];
   const seg = {};
@@ -233,7 +280,25 @@ export function parseStatusRow(d) {
   if (typeof d.value === 'number' && Number.isFinite(d.value)) seg.value = fmtNum(d.value);
   else if (typeof d.value === 'string' && cleanText(d.value, 24)) seg.value = cleanText(d.value, 24);
   else if (d.value !== undefined && d.value !== null) warnings.push('"value" is a number or a short string; ignored.');
+  if (depth === 0 && d.lines !== undefined && d.lines !== null) { // TUI-QPE 2026-10-20: one source, several lines (v1.1)
+    if (!Array.isArray(d.lines)) warnings.push('"lines" is a list of status rows; ignored.');
+    else {
+      const lines = [];
+      for (const x of d.lines.slice(0, MAX_LINES)) { const q = parseStatusRow(x, 1); if (q.error) warnings.push(`a line: ${q.error}`); else { lines.push(q.seg); warnings.push(...q.warnings); } }
+      if (lines.length) { seg.lines = lines; if (!seg.text) seg.text = lines.map((l) => l.text).join(' / ').slice(0, 160); }
+    }
+  }
+  if (d.cells !== undefined && d.cells !== null) { // TUI-QPE: coloured, responsive cells (v1.1)
+    const cells = parseCells(d.cells, warnings);
+    if (cells.length) { seg.cells = cells; if (!seg.text) seg.text = cellsText(cells); }
+  }
   if (!seg.text && !seg.value) return { error: 'Not a status row: it needs "text" (see quox rows contract).' };
+  if (d.grid !== undefined && d.grid !== null) {
+    if (typeof d.grid === 'string' && /^[A-Za-z0-9_-]{1,16}$/.test(d.grid)) seg.grid = d.grid; else warnings.push('"grid" is a short name (letters, digits, - and _); ignored.');
+  }
+  if (d.min_cols !== undefined && d.min_cols !== null) {
+    if (Number.isInteger(d.min_cols) && d.min_cols >= 20 && d.min_cols <= 400) seg.minCols = d.min_cols; else warnings.push('"min_cols" is a whole number from 20 to 400; ignored.');
+  }
   if (d.tone !== undefined && d.tone !== null) {
     if (STATUS_ROW_TONES.includes(d.tone)) { if (d.tone !== 'neutral') seg.tone = d.tone; }
     else warnings.push(`"tone" is one of ${STATUS_ROW_TONES.join(', ')}; "${cleanText(d.tone, 16)}" shows as neutral.`);
@@ -620,6 +685,12 @@ export function rowParts(st, { now = Date.now(), labelW = 0 } = {}) {
   const live = st.status === 'ok' || (st.status === 'error' && d.role !== 'error');
   if (!live || st.status === 'loading') return [[d.text, d.role]];
   const label = row.label || seg?.label || '';
+  if (seg?.cells?.length) { // TUI-QPE: one cells row on its own (quox rows test); RowsBar uses layoutRows
+    const out = label ? [[label + ' ', 'brand', true]] : [];
+    seg.cells.forEach((c, i) => { if (i) out.push([CELL_SEP, 'label']); for (const p of c.parts) out.push(partSeg(p)); });
+    if (st.status === 'error') out.push([` · ${ageMark(now - st.at)} old`, 'warn']);
+    return out;
+  }
   const toneR = seg?.tone ? toneRole(seg.tone) : null;
   if (!label && !seg?.tone && !seg?.value && !seg?.trend) return [[d.text, d.role]];
   const out = [];
@@ -651,6 +722,178 @@ export function clipParts(parts, width) {
   return out;
 }
 
+/* ---- cells layout (TUI-QPE) ---------------------------------------------------------------- */
+
+export const CELL_SEP = ' │ ';
+const W = (t) => cellWidth(String(t));
+const cellW = (c) => c.parts.reduce((a, p) => a + W(p.text), 0);
+const cellsW = (cs) => cs.reduce((a, c, i) => a + cellW(c) + (i ? W(CELL_SEP) : 0), 0);
+
+/**
+ * cells -> the cells that fit in `room` columns. Whole items go, lowest `keep` first (a tie drops the rightmost); an
+ * item with no keep stays. If even the kept items do not fit, the line ends at a word boundary with … (never mid-word).
+ */
+/** Drop the one lowest-keep item (a tie drops the rightmost; a part takes its group with it). -> new cells, or null. */
+export function dropLowest(cells) {
+  let best = null;
+  cells.forEach((c, i) => {
+    const cand = (keep, pos, j) => { if (keep == null) return; if (!best || keep < best.keep || (keep === best.keep && pos > best.pos)) best = { keep, pos, i, j }; };
+    cand(c.keep, i * 1000 + 999, -1);
+    c.parts.forEach((p, j) => cand(p.keep, i * 1000 + j, j));
+  });
+  if (!best) return null;
+  const cs = cells.map((c) => ({ ...c, parts: [...c.parts] }));
+  if (best.j < 0) cs.splice(best.i, 1);
+  else {
+    const c = cs[best.i]; const g = c.parts[best.j].group;
+    c.parts = lead(g ? c.parts.filter((p) => p.group !== g) : c.parts.filter((_, j) => j !== best.j));
+    if (!c.parts.length) cs.splice(best.i, 1);
+  }
+  return cs;
+}
+
+export function fitCells(cells, room) {
+  let cs = (cells || []).map((c) => ({ ...c, parts: c.parts.map((p) => ({ ...p })) }));
+  while (cellsW(cs) > room) { const next = dropLowest(cs); if (!next) break; cs = next; }
+  if (cellsW(cs) <= room) return { cells: cs, clipped: false };
+  // Still too wide with only the must-keep items: cut at the last word that fits.
+  const out = []; let used = 0; const max = Math.max(1, room - 1);
+  for (let i = 0; i < cs.length; i++) {
+    const parts = [];
+    if (i) { if (used + W(CELL_SEP) > max) break; used += W(CELL_SEP); }
+    let full = true;
+    for (const p of cs[i].parts) {
+      const w = W(p.text);
+      if (used + w <= max) { parts.push(p); used += w; continue; }
+      const words = p.text.split(/(\s+)/); let t = '';
+      for (const wd of words) { if (used + W(t + wd) > max) break; t += wd; }
+      t = t.replace(/\s+$/, '');
+      if (t.trim()) { parts.push({ ...p, text: t }); used += W(t); } // whole words only, so this is a word boundary
+      full = false; break;
+    }
+    if (parts.length) out.push({ ...cs[i], parts });
+    if (!full) break;
+  }
+  if (!out.length) out.push({ parts: [{ text: '' }] });
+  const last = out[out.length - 1].parts; last[last.length - 1] = { ...last[last.length - 1], text: last[last.length - 1].text.replace(/\s+$/, '') };
+  last.push({ text: '…' });
+  return { cells: out, clipped: true };
+}
+
+/** A cell whose first item was dropped must not start with its joiner (" · CLI 578/958"): trim a leading " · ". */
+const lead = (parts) => (parts.length && /^\s*·\s*/.test(parts[0].text) ? [{ ...parts[0], text: parts[0].text.replace(/^\s*·\s*/, '') }, ...parts.slice(1)] : parts);
+
+/** One part -> a [text, role, bold] segment (the RowsBar shape). Tones are palette roles, never grey. */
+const partSeg = (p) => [p.text, p.tone ? toneRole(p.tone) : 'prose', Boolean(p.bold)];
+
+/** States whose seg has cells and something to show. */
+const hasCells = (st) => Boolean(st?.seg?.cells?.length) && (st.status === 'ok' || (st.status === 'error' && st.text));
+
+/**
+ * The rows RowsBar draws at `cols`, in order -> [{ st, parts }]: rows below their min_cols are left out; cells rows
+ * are fitted, and rows sharing a `grid` share a lead (label) column and pad their cells so the separators line up.
+ * Other rows keep the classic rowParts + clipParts path, unchanged.
+ */
+/**
+ * Rows -> one state per drawn line: a row whose seg has `lines` becomes one state per line (ids `<id>.<n>`, the row's
+ * label on the first only, the row's grid unless a line names its own). Other rows pass through unchanged.
+ */
+export function expandLines(states) {
+  const out = [];
+  for (const st of states || []) {
+    const ls = st?.seg?.lines;
+    if (!ls?.length || !(st.status === 'ok' || (st.status === 'error' && st.text))) { out.push(st); continue; }
+    ls.forEach((seg, i) => out.push({ ...st, row: { ...st.row, id: `${st.row.id}.${i + 1}`, label: i === 0 ? st.row.label : '' },
+      text: seg.text, seg: { ...seg, grid: seg.grid || st.seg.grid || `#${st.row.id}`, ...(i === 0 ? {} : { label: undefined }) } }));
+  }
+  return out;
+}
+
+export function layoutRows(states, cols, { now = Date.now() } = {}) {
+  const shown = expandLines(states).filter((st) => !(st?.seg?.minCols && cols < st.seg.minCols)).slice(0, MAX_LINES);
+  const room = Math.max(1, cols - 2);
+  const labelW = labelWidth(shown.filter((st) => !hasCells(st)));
+  const groups = new Map();
+  for (const st of shown) if (hasCells(st)) { const g = st.seg.grid || `#${st.row.id}`; if (!groups.has(g)) groups.set(g, []); groups.get(g).push(st); }
+  const done = new Map();
+  for (const list of groups.values()) {
+    const leadOf = (st) => String(st.row.label || st.seg.label || '');
+    const leadW = Math.min(16, Math.max(0, ...list.map((st) => W(leadOf(st)))));
+    const leadCols = leadW ? leadW + 1 : 0;
+    const roomL = room - leadCols;
+    const base = list.map((st) => {
+      const cells = st.seg.cells.map((c) => ({ ...c, parts: [...c.parts] }));
+      return cells;
+    });
+    // `keep` is ONE priority across the grid. The layout drops the shortest prefix of the grid-wide order (lowest keep
+    // first; a tie drops the rightmost, then the lower row) that lets every row fit with its columns lined up. A wider
+    // window can only shorten that prefix, so it never shows less (2026-10-20: a greedy per-row pass did, at 68/69 cols).
+    const units = [];
+    base.forEach((cells, r) => cells.forEach((c, i) => {
+      if (c.keep != null) units.push({ r, i, j: -1, keep: c.keep, pos: i * 1000 + 999 });
+      const seenG = new Set();
+      c.parts.forEach((p, j) => {
+        if (p.keep == null) return;
+        if (p.group) { if (seenG.has(p.group)) return; seenG.add(p.group); }
+        units.push({ r, i, j, group: p.group, keep: p.keep, pos: i * 1000 + j });
+      });
+    }));
+    units.sort((x, y) => x.keep - y.keep || y.pos - x.pos || y.r - x.r);
+    const build = (k) => {
+      const gone = units.slice(0, k);
+      return base.map((cells, r) => cells.map((c, i) => {
+        if (gone.some((u) => u.r === r && u.i === i && u.j < 0)) return null;
+        const parts = c.parts.filter((p, j) => !gone.some((u) => u.r === r && u.i === i && u.j >= 0 && (u.group ? p.group === u.group : u.j === j)));
+        return parts.length ? { ...c, parts: lead(parts) } : null;
+      }).filter(Boolean));
+    };
+    const colWidths = (rows) => { const w = []; for (const cs of rows) cs.forEach((c, i) => { if (i < cs.length - 1) w[i] = Math.max(w[i] || 0, cellW(c)); }); return w; };
+    const alignedW = (cs, w) => cs.reduce((a, c, i) => a + (i < cs.length - 1 ? Math.max(w[i] || 0, cellW(c)) : cellW(c)) + (i ? W(CELL_SEP) : 0), 0);
+    let rows = null;
+    for (let k = 0; k <= units.length; k++) {
+      const cand = build(k);
+      // A row whose must-keep items alone are too wide is cut at a word below and left out of the column widths.
+      const over = cand.map((cs) => cellsW(cs) > roomL);
+      const w = colWidths(cand.filter((_, r) => !over[r]));
+      if (cand.every((cs, r) => over[r] ? !units.slice(k).some((u) => u.r === r) : alignedW(cs, w) <= roomL)) { rows = cand; break; }
+    }
+    rows ??= build(units.length);
+    const over = rows.map((cs) => cellsW(cs) > roomL);
+    const colW = colWidths(rows.filter((_, r) => !over[r]));
+    list.forEach((st, r) => {
+      const f = over[r] ? fitCells(rows[r], roomL) : { cells: rows[r], clipped: false };
+      const pads = f.cells.map((c, i) => (!f.clipped && i < f.cells.length - 1 ? Math.max(0, (colW[i] || 0) - cellW(c)) : 0));
+      const out = [];
+      if (leadCols) out.push([leadOf(st) + ' '.repeat(Math.max(0, leadW - W(leadOf(st)))) + ' ', 'brand', true]);
+      f.cells.forEach((c, i) => {
+        if (i) out.push([CELL_SEP, 'label']);
+        for (const p of c.parts) out.push(partSeg(p));
+        if (pads[i]) out.push([' '.repeat(pads[i]), 'prose']);
+      });
+      done.set(st, out);
+    });
+    // The age of a stale value is said ONCE per grid and only in space the fit left over, never in the fit budget:
+    // appended per line it pushed whole items out every minute as the data aged (coordinator 2026-10-20 03:39Z).
+    // It goes on the first stale line that has room, else the line with the most room; with no room it is left out.
+    const stale = list.filter((st) => st.status === 'error' && st.at != null);
+    if (stale.length) {
+      const age = ` · ${ageMark(now - Math.min(...stale.map((st) => st.at)))} old`;
+      const used = (st) => done.get(st).reduce((a, [t]) => a + W(t), 0);
+      const roomOf = (st) => room - used(st);
+      const pick = stale.find((st) => roomOf(st) >= W(age)) || [...list].sort((a, b) => roomOf(b) - roomOf(a))[0];
+      if (pick && roomOf(pick) >= W(age)) done.get(pick).push([age, 'warn']);
+    }
+  }
+  return shown.map((st) => ({ st, parts: done.get(st) || clipParts(rowParts(st, { now, labelW }), room) }));
+}
+
+/** /qpe rows N: keep the first n rows of a grid (0 hides the grid). Rows not in the grid are untouched. */
+export function limitGrid(states, grid, n) {
+  if (n == null || !Number.isInteger(n) || n < 0) return states;
+  let seen = 0;
+  return (states || []).filter((st) => st?.seg?.grid !== grid || ++seen <= n);
+}
+
 /* ---- local-only store for cmd rows -------------------------------------------------------- */
 
 export const localRowsFile = () => join(homedir(), '.config', 'quox', 'quoxon-rows.local.json');

package/lib/quoxon/screenContext.js

@@ -48,7 +48,7 @@ const age = (ms) => {
 };
 
 /** A line the user cannot have meant as a command they want repeated (PIN-bearing verbs): name only. */
-const PIN_VERBS = /^\/(authenticate|authorise|authorize|pin|login|connect|key)\b/i;
+const PIN_VERBS = /^\/(authenticate|authorise|authorize|pin|login|connect|key|verify-email)\b/i;
 
 function whoSection(w) {
   const bits = [];

package/lib/quoxon/secretShape.js

@@ -0,0 +1,86 @@
+/**
+ * QUOXON-SECRET-GUARD: one detector for secret-shaped text, shared by the composer (offer before send), the
+ * history writer and the transcript writer (redact before write). Low false positives on purpose: a bare number
+ * never matches unless a keyword sits next to it, or it is a Luhn-valid card number.
+ */
+const REDACTED = '[REDACTED';
+
+const luhn = (digits) => {
+  let sum = 0, dbl = false;
+  for (let i = digits.length - 1; i >= 0; i--) { let d = digits.charCodeAt(i) - 48; if (dbl) { d *= 2; if (d > 9) d -= 9; } sum += d; dbl = !dbl; }
+  return sum % 10 === 0;
+};
+
+// keyword, then a value: after ":" or "=" anything non-space; after plain space/"is" only a value carrying a digit (4+ chars)
+const KEYWORDS = [
+  ['pin', 'pin'], ['passcode', 'pass\\s?code'], ['password', 'password|passwd|pass\\s?word'],
+  ['api-key', 'api[ _-]?key'], ['secret', 'secret'], ['token', 'token']
+];
+const kwRe = (kw) => new RegExp(`\\b(?:${kw})\\b(?:[ \\t]+(?:number|no\\.?|code))?(?:[ \\t]*[:=][ \\t]*["']?([^\\s"',;]+)|[ \\t]+(?:is[ \\t]+)?["']?([^\\s"',;]*\\d[^\\s"',;]*))`, 'gi');
+
+const ULID = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+const trimVal = (v) => v.replace(/^[(\[`<*_]+/, '').replace(/[)\]`>*_.,;:!?]+$/, '');
+/**
+ * Precision mode: is a keyword-adjacent value really secret-shaped, or just prose ("PIN ask", "token budget",
+ * a ULID, a path, a placeholder)? pin/passcode need a 4-8 digit run; the others need a 8+ char value that mixes
+ * letters and digits (or carries a symbol) and is not an id, path, url, placeholder or short hex.
+ */
+function preciseValueOk(kind, raw) {
+  if (/^[<$\{\[~\/]|^[a-z]+:\/\/|\.\.\.|^\$|^\.{0,2}\//i.test(raw)) return false;
+  const v = trimVal(raw);
+  if (kind === 'pin' || kind === 'passcode') return /^\d{4,8}$/.test(v);
+  if (v.length < 8 || ULID.test(v) || /^[0-9a-f]{7,12}$/i.test(v) || /^\d{4}-\d{2}-\d{2}/.test(v)) return false;
+  if (/[<>{}()/\\]|^\W/.test(v) && !/^[\w!@#$%^&*+=.-]+$/.test(v)) return false;
+  return /[A-Za-z]/.test(v) && /\d/.test(v);
+}
+const CARD_FORM = /^(?:\d{13,19}|\d{4}(?:[ -]\d{4}){2,3}(?:[ -]\d{1,3})?|\d{4}[ -]\d{6}[ -]\d{5})$/;
+
+/** -> [{ kind, start, end }] value spans, sorted, non-overlapping. opts.precise = memory-sync mode (words are not secrets). */
+export function findSecrets(text, opts = {}) {
+  const s = String(text ?? '');
+  const precise = !!opts.precise;
+  const hits = [];
+  const add = (kind, start, end) => { if (!/^\[redacted/i.test(s.slice(start, end))) hits.push({ kind, start, end }); };
+  const grp = (m, i) => { const v = m[i]; const at = m.index + m[0].lastIndexOf(v); return [at, at + v.length]; };
+  for (const [kind, kw] of KEYWORDS) {
+    for (const m of s.matchAll(kwRe(kw))) {
+      const i = m[1] ? 1 : 2;
+      if (i === 2 && m[2].length < 4) continue;
+      if (i === 1 && m[1].length < 2) continue;
+      if (precise && !preciseValueOk(kind, m[i])) continue;
+      add(kind, ...grp(m, i));
+    }
+  }
+  for (const m of s.matchAll(/sort[ \t]*code[^\d\n]{0,15}(\d{2}-?\d{2}-?\d{2})(?!\d)/gi)) add('sort-code', ...grp(m, 1));
+  for (const m of s.matchAll(/account(?:[ \t]*(?:number|no\.?|num))?[^\d\n]{0,15}(\d{8})(?!\d)/gi)) add('account-number', ...grp(m, 1));
+  for (const m of s.matchAll(/customer[ \t]*(?:number|no\.?|num|id)[^\d\n]{0,15}(\d{6,})(?!\d)/gi)) add('customer-number', ...grp(m, 1));
+  for (const m of s.matchAll(/(?<![\d-])\d(?:[ -]?\d){12,18}(?![\d-])/g)) {
+    const d = m[0].replace(/[ -]/g, '');
+    if (precise) {
+      if (!CARD_FORM.test(m[0]) || /[A-Za-z_]/.test(s[m.index - 1] ?? '') || /[A-Za-z_]/.test(s[m.index + m[0].length] ?? '')) continue;
+      if (/^\d{4}(?:-\d{4}){3}$/.test(m[0]) && /[0-9a-f]{4,}-$/i.test(s.slice(Math.max(0, m.index - 6), m.index))) continue;
+    }
+    if (d.length >= 13 && d.length <= 19 && luhn(d)) add('card-number', m.index, m.index + m[0].length);
+  }
+  for (const m of s.matchAll(/\bsk-[A-Za-z0-9_-]{8,}/g)) if (!precise || m[0].length >= 20) add('api-key', m.index, m.index + m[0].length);
+  for (const m of s.matchAll(/\b(?:ghp|gho|ghs)_[A-Za-z0-9]{16,}/g)) add('api-key', m.index, m.index + m[0].length);
+  for (const m of s.matchAll(/\bAKIA[0-9A-Z]{16}\b/g)) add('api-key', m.index, m.index + m[0].length);
+  for (const m of s.matchAll(/\beyJ[A-Za-z0-9_-]{8,}(?:\.[A-Za-z0-9_-]+){1,2}/g)) add('jwt', m.index, m.index + m[0].length);
+  hits.sort((a, b) => a.start - b.start || b.end - a.end);
+  const out = [];
+  for (const h of hits) { const last = out[out.length - 1]; if (last && h.start < last.end) continue; out.push(h); }
+  return out;
+}
+
+/** -> unique kinds in order of appearance ([] when clean). */
+export const secretKinds = (text, opts) => [...new Set(findSecrets(text, opts).map(h => h.kind))];
+
+/** Matched values become [REDACTED:<kind>]; everything else is untouched. */
+export function redactSecrets(text) {
+  if (typeof text !== 'string' || !text) return text;
+  const hits = findSecrets(text);
+  if (!hits.length) return text;
+  let out = '', at = 0;
+  for (const h of hits) { out += text.slice(at, h.start) + `${REDACTED}:${h.kind}]`; at = h.end; }
+  return out + text.slice(at);
+}

package/lib/quoxon/serverChip.js

@@ -0,0 +1,42 @@
+// TUI-STATUS: which REGISTERED server this quox runs on (the fleet host registry, `quox fleet hosts`).
+// Pure matcher + a once-per-session resolver. Unregistered or any failure -> null: the status line shows nothing,
+// and never the raw hostname (screenshots).
+import os from 'node:os';
+
+/** This machine's non-internal IPv4 addresses. */
+export function localIps(ifaces = os.networkInterfaces()) {
+  return Object.values(ifaces || {}).flat().filter(a => a && a.family === 'IPv4' && !a.internal).map(a => a.address);
+}
+
+const bare = (s) => String(s || '').toLowerCase().split('.')[0];
+
+/** hosts: [{ id, ip, group }] -> { name, role } for the host matching this machine's hostname or IP, else null. */
+export function matchServer(hosts, { hostname, ips = [] } = {}, registry) {
+  if (!Array.isArray(hosts)) return null;
+  const hn = bare(hostname);
+  const mine = new Set(ips);
+  const hit = hosts.find(h => h && h.id && hn && bare(h.id) === hn)
+    || hosts.find(h => h && h.id && h.ip && h.ip !== '0.0.0.0' && mine.has(h.ip));
+  if (!hit) return null;
+  // DEVFLEET: with a registry the role is the server's PURPOSE (e.g. "main dev"), never the Bastion group; no entry -> nothing.
+  if (registry !== undefined) { const p = registry?.servers?.[hit.id]?.purpose; return { name: String(hit.id), role: p ? String(p) : null }; }
+  return { name: String(hit.id), role: hit.group ? String(hit.group) : null };
+}
+
+/** The profile's instance host when it is NOT this machine (a remote instance), else null. */
+export function remoteHost(url, { hostname, ips = [] } = {}) {
+  let h;
+  try { h = new URL(url).hostname.toLowerCase(); } catch { return null; }
+  if (!h || h === 'localhost' || h === '::1' || h === '[::1]' || h.startsWith('127.') || mine(h, ips) || bare(h) === bare(hostname)) return null;
+  return h;
+}
+function mine(h, ips) { return ips.includes(h); }
+
+/** -> { name, role, remote } | null. Never throws; `listHosts` is async () => hosts[]. */
+export async function resolveServerChip({ listHosts, hostname = os.hostname(), ips = localIps(), url = null, registry } = {}) {
+  try {
+    const m = matchServer(await listHosts(), { hostname, ips }, registry);
+    if (!m) return null;
+    return { ...m, remote: url ? remoteHost(url, { hostname, ips }) : null };
+  } catch { return null; }
+}

package/lib/quoxon/session.js

@@ -141,6 +141,16 @@ export function sayMissText(input, rows, cap = 8) {
   ].filter(Boolean).join('\n');
 }
 
+/** SAY-LAST-TARGET: a word that is a URL, a path or an address (has / : or .) is never a slot or session name. */
+export const looksLikeAddress = (w) => /[/:.]/.test(String(w || ''));
+
+/** SAY-LAST-TARGET: "/say" with no usable target and nothing recent to offer: who to, and who is reachable. */
+export function sayWhoText(rows, cap = 8) {
+  const held = (Array.isArray(rows) ? rows : []).filter(r => r?.name && r.holder_session && r.state !== 'free');
+  const reach = held.slice(0, cap).map(r => `${r.name} (${r.holder_session})`).join(', ');
+  return ['Who to? /say <slot> <message>', reach ? `Reachable now: ${reach}${held.length > cap ? `, +${held.length - cap} more (/slots)` : ''}` : null].filter(Boolean).join('\n');
+}
+
 const idOf = (a) => String(a?.agent_id ?? a?.id ?? a?.name ?? '');
 const nameOf = (a) => String(a?.name ?? a?.agent_id ?? a?.id ?? '');