quoxcli 0.2.0 → 0.4.0

package/lib/quoxon/motion/level.js

@@ -0,0 +1,91 @@
+/**
+ * Motion levels (CLI-QUOX F3). One setting, four steps, chosen in /config or with QUOX_MOTION:
+ *
+ *   quiet       static except the elapsed timer (the old "reduced motion"; QUOX_REDUCED_MOTION=1 still means it)
+ *   calm        the default: exactly what shipped before levels (Orbit & Lock, the status Q, reveals, the ring)
+ *   expressive  calm, plus a short ignition glow when a tool row starts and a handoff dot while delegating
+ *   cinematic   expressive, plus the dragon: it greets you after Orbit & Lock on every launch, and plays a mood
+ *               for approvals (wide eyes, amber glint), success (a wink) and failure (a puff of smoke)
+ *
+ * Pure: no process access except through the env argument, no timers. The frame helpers return cells
+ * { ch, rgb } like every other motion module, so the terminal and the web draw them the same way.
+ */
+export const LEVELS = ['quiet', 'calm', 'expressive', 'cinematic'];
+export const DEFAULT_LEVEL = 'calm';
+
+/** A saved or typed value -> a level, or null. The pre-levels values map across: full = calm, reduced = quiet. */
+export function normaliseLevel(v) {
+  const s = String(v ?? '').trim().toLowerCase();
+  if (s === 'full') return 'calm';
+  if (s === 'reduced') return 'quiet';
+  return LEVELS.includes(s) ? s : null;
+}
+
+/** The level in force. QUOX_REDUCED_MOTION=1 and QUOX_TUI_LITE always mean quiet (accessibility wins). */
+export function motionLevel(env = process.env) {
+  if (env.QUOX_REDUCED_MOTION === '1' || env.QUOX_TUI_LITE) return 'quiet';
+  return normaliseLevel(env.QUOX_MOTION) || DEFAULT_LEVEL;
+}
+
+export const atLeast = (level, min) => LEVELS.indexOf(normaliseLevel(level) || DEFAULT_LEVEL) >= LEVELS.indexOf(min);
+
+/** What each level turns on. launchEgg: the rare dragon greeting on launch (cinematic greets every time instead). */
+export function levelFeatures(level) {
+  const l = normaliseLevel(level) || DEFAULT_LEVEL;
+  return {
+    animate: l !== 'quiet',
+    ignition: atLeast(l, 'expressive'),
+    handoff: atLeast(l, 'expressive'),
+    introDragon: l === 'cinematic',
+    moods: l === 'cinematic',
+    launchEgg: l === 'calm' || l === 'expressive',
+  };
+}
+
+const clamp = (x, a = 0, b = 1) => Math.max(a, Math.min(b, x));
+
+// ---- tool-row ignition glow --------------------------------------------------------------------------------
+export const IGNITION_MS = 700;
+/** Glow 0..1 at ms since a tool row started running: up in 80 ms, then an eased fall to 0 at IGNITION_MS. */
+export function ignitionGlow(age) {
+  if (!(age > 0) || age >= IGNITION_MS) return 0;
+  if (age <= 80) return age / 80;
+  const u = (age - 80) / (IGNITION_MS - 80);
+  return (1 - u) ** 2;
+}
+
+// ---- handoff dot -------------------------------------------------------------------------------------------
+export const HANDOFF_MS = 900;
+const SKY = [56, 189, 248], VIOLET = [168, 85, 247], DIM = [58, 66, 82];
+const mix = (a, b, t) => a.map((v, i) => Math.round(v + (b[i] - v) * t));
+/**
+ * The handoff track at t ms: n cells, a bright dot travelling from Quox (left) to the agent it is handing to
+ * (right) once every HANDOFF_MS, with one fading cell behind it. The dot shifts sky to violet as it goes.
+ * still: the dot rests at the target (reduced motion never calls this, but a frozen frame must read right).
+ */
+export function handoffFrame(t, n = 6, { mono = false, still = false } = {}) {
+  const u = still ? 0.999 : (((t % HANDOFF_MS) + HANDOFF_MS) % HANDOFF_MS) / HANDOFF_MS;
+  const at = Math.min(n - 1, Math.floor(u * n));
+  return Array.from({ length: n }, (_, i) => {
+    const pos = n > 1 ? i / (n - 1) : 1;
+    if (i === at) return { ch: '●', rgb: mono ? null : mix(SKY, VIOLET, pos) };
+    if (i === at - 1 && !still) return { ch: '•', rgb: mono ? null : mix(DIM, mix(SKY, VIOLET, pos), 0.55) };
+    return { ch: '·', rgb: mono ? null : mix(DIM, SKY, 0.25 * clamp(pos)) };
+  });
+}
+
+// ---- dragon moods (cinematic) ------------------------------------------------------------------------------
+const FAILED_TURN = new Set(['failed', 'unconfirmed']); // the same reading as the sound earcons (sound/mapping.js)
+/**
+ * prevState + action + nextState -> the mood the dragon should play, or null. Only accepted state CHANGES
+ * count: an approval card appearing (waiting), a running turn finishing (success / failure). An interrupted
+ * turn is the human pressing Esc: no reaction.
+ */
+export function moodForEvent(prev, action, next) {
+  if (!prev || !action || !next) return null;
+  if ((next.approvals?.length || 0) > (prev.approvals?.length || 0)) return 'waiting';
+  if (action.type !== 'event' || action.ev?.type !== 'turn.finished' || !prev.turn) return null;
+  const status = action.ev.status || 'completed';
+  if (FAILED_TURN.has(status)) return 'failure';
+  return status === 'completed' ? 'success' : null;
+}

package/lib/quoxon/mouse.js

@@ -0,0 +1,222 @@
+/**
+ * QUOXON-MOUSE (owner 2026-10-15: "when I click on '◆ QLOOP-ENGINE' enter /say [slot]", "select a chunk of text I
+ * typed and delete it"). Optional, OFF by default: mouse tracking makes the terminal send clicks to Quox, so
+ * selecting or copying text then needs Shift+drag in most terminals (said when it is turned on).
+ *
+ * Pure parts only (the app wires them):
+ * - MOUSE_ON / MOUSE_OFF: SGR button tracking with drag (1000 + 1002 + 1006). Never any-motion (1003).
+ * - createScreenMirror: what Ink has put on the screen, as plain lines. Fed every string Ink writes (term.js), it
+ *   models exactly Ink's output: text, newlines, eraseLines (frame repaints) and clear-terminal. The live frame is
+ *   the last write; everything above it is static history. Wrapping is applied at the current width when read, so
+ *   a resize reflows it the way the terminal does.
+ * - screenHit: a click's screen row -> the mirror line under it. Rows are counted up from the cursor (which Ink
+ *   always leaves on the line after the frame), read with a cursor position report (DSR) at click time, so the
+ *   map holds whether the frame sits at the bottom of a full screen or halfway down a fresh one.
+ * - classifyClick: what that line is (a ◆ sender, a card's answer key label, the shared ask's y/N/c).
+ * - composerIndexAt: a click in the composer rows -> a buffer index, through Ink's word wrap.
+ */
+import { graphemes, composerFrom } from './textBuffer.js';
+
+/** The logical line (between newlines) holding buffer index `idx` -> { from, to }; a triple-click selects it. */
+export function lineAt(text, idx) {
+  const t = String(text);
+  const i = Math.max(0, Math.min(idx, t.length));
+  const from = t.lastIndexOf('\n', i - 1) + 1;
+  const nl = t.indexOf('\n', i);
+  return { from, to: nl < 0 ? t.length : nl };
+}
+
+export const MOUSE_HINT = 'Click your draft to place the cursor, drag to select (copies), double-click a word, triple-click a line. Shift+drag uses your terminal\'s own selection in most terminals. /mouse off gives native selection back.';
+
+export const MOUSE_ON = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
+export const MOUSE_OFF = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+export const DSR = '\x1b[6n';
+/** Two presses on the same cell within this window are a double-click. */
+export const DOUBLE_MS = 400;
+/** How long a click waits for the terminal's cursor report before it is dropped. */
+export const DSR_TIMEOUT_MS = 400;
+
+export function mouseOnNote() {
+  return 'Mouse on. Click a ◆ sender to reply, click a card\'s y / n / c to answer, click or drag in your draft to place the cursor or select (Backspace deletes, typing replaces, double-click selects a word, triple-click a line). While it is on your terminal sends clicks and the wheel to Quox: hold Shift to select or copy text (Option on macOS Terminal and iTerm2), and use Shift+wheel or the scrollbar to scroll back. /mouse off returns all of it.';
+}
+
+// ---- cell widths --------------------------------------------------------------------------------
+const WIDE = /\p{Extended_Pictographic}/u;
+const EAW = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦]/u;
+/** Terminal cells one grapheme takes: 2 for emoji presentation and East Asian wide, else 1. */
+export function cellWidth(g) {
+  const cp = g.codePointAt(0);
+  if (EAW.test(g)) return 2;
+  if (WIDE.test(g) && (cp >= 0x1f000 || g.includes('️'))) return 2;
+  return 1;
+}
+const cellsOf = (s) => graphemes(String(s)).reduce((n, x) => n + cellWidth(x.text), 0);
+/** Grapheme index in `gs` covering 0-based cell `col` (gs.length when past the end). */
+function cellToIndex(gs, col) {
+  let at = 0;
+  for (let i = 0; i < gs.length; i++) { const w = cellWidth(gs[i].text); if (col < at + w) return i; at += w; }
+  return gs.length;
+}
+/** 1-based start cell of grapheme index `i`. */
+function indexToCell(gs, i) { let at = 1; for (let k = 0; k < i && k < gs.length; k++) at += cellWidth(gs[k].text); return at; }
+
+// ---- screen mirror ------------------------------------------------------------------------------
+const ANSI_RE = /\x1b\[[0-9;?<>=]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][0-9A-Za-z]|\x1b[=>78]/g;
+const ERASE_RE = /^((?:\x1b\[2K\x1b\[1A)*\x1b\[2K\x1b\[G)/;
+const CLEAR_RE = /\x1b\[2J|\x1bc/;
+
+/** Wrap one plain line into rows of at most `cols` cells (what the terminal shows). */
+function wrapRows(line, cols) {
+  if (!(cols > 0)) return [line];
+  const gs = graphemes(line);
+  if (!gs.length) return [''];
+  const out = []; let row = ''; let w = 0;
+  for (const g of gs) {
+    const cw = cellWidth(g.text);
+    if (w + cw > cols) { out.push(row); row = ''; w = 0; }
+    row += g.text; w += cw;
+  }
+  out.push(row);
+  return out;
+}
+
+export function createScreenMirror({ columns = () => null, cap = 3000 } = {}) {
+  let lines = ['']; // logical lines; the last one is the cursor line
+  let frameLen = 0; // logical lines written by the last write (the live frame, once Ink has written it)
+  const append = (text) => {
+    const parts = text.replace(ANSI_RE, '').replace(/\r/g, '').split('\n');
+    lines[lines.length - 1] += parts[0];
+    for (let i = 1; i < parts.length; i++) lines.push(parts[i]);
+    if (lines.length > cap) lines = lines.slice(lines.length - cap);
+    return parts.length - 1;
+  };
+  const m = {
+    /** One string Ink wrote, before any diffing. */
+    write(chunk) {
+      let s = String(chunk);
+      const clear = s.search(CLEAR_RE);
+      if (clear >= 0) {
+        const all = [...s.matchAll(/\x1b\[2J|\x1b\[3J|\x1b\[H|\x1bc/g)];
+        const last = all[all.length - 1];
+        s = s.slice(last.index + last[0].length);
+        lines = ['']; frameLen = 0;
+      }
+      const e = ERASE_RE.exec(s);
+      if (e) {
+        const n = (e[1].match(/\x1b\[2K/g) || []).length;
+        const drop = Math.min(n - 1, lines.length - 1);
+        lines.length -= drop;
+        lines[lines.length - 1] = '';
+        s = s.slice(e[1].length);
+      }
+      const plain = s.replace(ANSI_RE, '');
+      if (!plain) return;
+      const rows = append(s);
+      if (rows > 0) frameLen = rows;
+    },
+    /** Test helper: Ink repainting its frame as these lines. */
+    frame(fl) { m.write(`\x1b[2K\x1b[G${fl.join('\n')}\n`); },
+    /** Raw output we cannot place (a hand-over, a child on the terminal): forget what is above. */
+    reset() { lines = ['']; frameLen = 0; },
+    /** -> { rows, frameStart, staticRows, frameRows }: wrapped at the current width, cursor line excluded. */
+    snapshot() {
+      const cols = columns();
+      const body = lines.slice(0, -1);
+      const fl = Math.min(frameLen, body.length);
+      const stat = body.slice(0, body.length - fl).flatMap(l => wrapRows(l, cols));
+      const fr = body.slice(body.length - fl).flatMap(l => wrapRows(l, cols));
+      return { rows: [...stat, ...fr], frameStart: stat.length, staticRows: stat, frameRows: fr };
+    }
+  };
+  return m;
+}
+
+/** A click at 1-based (x, y) with the cursor on screen row `cursorRow` -> the line under it, or null. */
+export function screenHit(snap, cursorRow, x, y) {
+  if (!snap || !(cursorRow > 0)) return null;
+  const idx = snap.rows.length - (cursorRow - y);
+  if (y >= cursorRow || idx < 0 || idx >= snap.rows.length) return null;
+  return {
+    text: snap.rows[idx], col: x, inFrame: idx >= snap.frameStart,
+    frameRow: idx - snap.frameStart, frameLines: snap.rows.slice(snap.frameStart), rowsBelow: snap.rows.slice(idx + 1)
+  };
+}
+
+// ---- what was clicked ---------------------------------------------------------------------------
+const SENDER_RE = /^\s*◆ (\S+)( \(no reply address\))?/;
+const CARD_KEY_RE = /(?<![\w/])([ync]) (approve|deny|chat|yes)(?![\w])/g;
+const ASK_KEYS_RE = /(?<![\w/])(y|run)\/(N)\/(c)\s*$/;
+const isAskRow = (r) => /^\s*▶ /.test(r) && (ASK_KEYS_RE.test(r) || /\b[ync] (approve|deny|chat)\b/.test(r));
+
+/**
+ * -> { kind: 'sender', slot, who? } | { kind: 'key', key: 'y'|'n'|'c'|'run', source: 'approval'|'ask' } | null.
+ * A key needs the click ON its label. A card's labels count only in the live frame (a card is never answered from
+ * scrollback); an ask's y/N/c only when no newer ask sits below it on screen.
+ */
+export function classifyClick(hit) {
+  if (!hit || typeof hit.text !== 'string') return null;
+  const t = hit.text;
+  const gs = graphemes(t);
+  const s = SENDER_RE.exec(t);
+  if (s) return s[2] ? { kind: 'sender', slot: null, who: s[1] } : { kind: 'sender', slot: s[1].toLowerCase() };
+  const within = (from, len) => {
+    const gi = graphemes(t.slice(0, from)).length;
+    const a = indexToCell(gs, gi); const b = a + cellsOf(t.slice(from, from + len));
+    return hit.col >= a && hit.col < b;
+  };
+  if (hit.inFrame) {
+    CARD_KEY_RE.lastIndex = 0;
+    let m;
+    while ((m = CARD_KEY_RE.exec(t))) if (within(m.index, m[0].length)) return { kind: 'key', key: m[1], source: 'approval' };
+  }
+  const k = ASK_KEYS_RE.exec(t);
+  if (k && /^\s*▶ /.test(t)) {
+    if ((hit.rowsBelow || []).some(isAskRow)) return null;
+    const base = k.index + k[0].indexOf(k[1]);
+    const yPos = base, nPos = yPos + k[1].length + 1, cPos = nPos + 2;
+    if (within(yPos, k[1].length)) return { kind: 'key', key: k[1] === 'run' ? 'run' : 'y', source: 'ask' };
+    if (within(nPos, 1)) return { kind: 'key', key: 'n', source: 'ask' };
+    if (within(cPos, 1)) return { kind: 'key', key: 'c', source: 'ask' };
+  }
+  return null;
+}
+
+// ---- the composer -------------------------------------------------------------------------------
+const isRule = (r) => /^\s*─/.test(r || '');
+const isPrompt = (r) => /^› /.test(r || '') || r === '›';
+
+/**
+ * A click on frame row `row` (0-based), 1-based column `col` -> the buffer index under it, or null when the row is
+ * not one of the composer's. The composer is the "› " row right under a rule, down to the next rule.
+ */
+export function composerIndexAt(frameLines, row, col, buf) {
+  let top = -1;
+  for (let i = frameLines.length - 1; i >= 1; i--) if (isPrompt(frameLines[i]) && isRule(frameLines[i - 1])) { top = i; break; }
+  if (top < 0 || row < top) return null;
+  let bottom = top;
+  while (bottom < frameLines.length && !isRule(frameLines[bottom])) bottom++;
+  if (row >= bottom) return null;
+  if (!buf.text) return 0;
+  const lines = buf.text.split('\n');
+  const starts = []; { let o = 0; for (const l of lines) { starts.push(o); o += l.length + 1; } }
+  const from = composerFrom(buf);
+  let r = top;
+  for (let li = from; li < lines.length && r < bottom; li++) {
+    const T = graphemes(lines[li]);
+    let p = 0; let first = true;
+    const rest = () => T.slice(p).some(g => !/\s/.test(g.text)); // trailing spaces never take a row of their own
+    while (r < bottom && (first || rest())) {
+      const R = graphemes(String(frameLines[r]).replace(/\s+$/, '')).slice(2);
+      while (!first && p < T.length && /\s/.test(T[p].text) && R.length && !/\s/.test(R[0].text)) p++;
+      const take = Math.min(R.length, T.length - p);
+      if (r === row) {
+        const gi = Math.min(T.length, p + Math.min(cellToIndex(R, Math.max(0, col - 3)), take));
+        return starts[li] + (gi < T.length ? T[gi].index : lines[li].length);
+      }
+      p += Math.max(take, 0); r++; first = false;
+      if (take <= 0) break;
+    }
+  }
+  return buf.text.length;
+}
+

package/lib/quoxon/noai.js

@@ -0,0 +1,57 @@
+/**
+ * Z2H-R2B: what Quox does when NO AI provider is connected. A turn is answered locally (no server call),
+ * with a full friendly card; nothing here names one vendor as the default. "add a host" has a deterministic
+ * path that needs no AI.
+ */
+import { CHOICES } from './model.js';
+import { providerState } from './providers.js';
+
+export const NO_AI_STATUS = 'no AI connected';
+export const NO_AI_CARD = [
+  'No AI is connected yet. Pick one:',
+  '/connect openai (recommended), /connect anthropic, /connect ollama <host>, or /connect for the list.'
+];
+export const HOSTS_USAGE = '/hosts add';
+
+/** -> true when at least one provider is connected, false when readable and none is, null when nothing could be read. */
+export function anyProviderConnected(vault, caps) {
+  let known = false;
+  for (const c of CHOICES) {
+    const st = providerState({ cap: c.cap || c.id, vault: c.vault }, caps, vault).state;
+    if (st === 'connected') return true;
+    if (st !== 'unknown') known = true;
+  }
+  return known ? false : null;
+}
+
+export const asksAddHost = (text) => /^\s*(?:please\s+)?(?:(?:i\s+(?:want|need)\s+to|can\s+you|help\s+me|let'?s)\s+)?(?:add|connect|enrol+|enroll|register|onboard)\s+(?:a|my|another|the)?\s*(?:new\s+)?(?:host|server|machine|node|box)s?\b/i.test(String(text || '').replace(/[.?!]+\s*$/, ''));
+
+/** Z2H-R4: "watch my servers" and friends; watching starts with adding a host, which needs no AI. */
+export const asksWatchHosts = (text) => /^\s*(?:please\s+)?(?:(?:i\s+(?:want|need)\s+(?:you\s+)?to|can\s+you|help\s+me)\s+)?(?:watch|monitor|keep\s+an\s+eye\s+on|look\s+after|keep\s+watch\s+(?:on|over))\s+(?:my|our|the)\s+(?:\w+\s+)?(?:servers?|hosts?|machines?|nodes?|boxes|fleet|homelab|infrastructure|infra)\b/i.test(String(text || '').replace(/[.?!]+\s*$/, ''));
+
+/**
+ * The deterministic add-a-host lines. `base` = the server URL when known. `check` = the result of probing
+ * `${base}/install` ({ ok, status }) or null when it could not be read. Z2H-3c: a public install answered 503
+ * there (no QuoxAgent bundled), so the curl line we printed failed on the user's host; a failed probe now says
+ * so plainly instead of handing out a command that cannot work. Unreadable (null) keeps the old lines.
+ */
+export function addHostLines(base, check = null) {
+  const b = String(base || '').replace(/\/+$/, '') || '<your-quox-url>';
+  if (check && check.ok === false && Number(check.status) >= 400) {
+    return [
+      `This Quox cannot enrol hosts yet: its host installer is not available (${b}/install answered HTTP ${check.status}).`,
+      'The QuoxAgent installer is not bundled in this install, so the add-a-host command would fail on your machine.',
+      'Nothing was changed on either machine.'
+    ];
+  }
+  return [
+    'To add a host, no AI needed. On the machine you want to add, run:',
+    // REL-423: never `curl | sudo bash`: that pipe exits 0 when the download fails (TLS error, HTTP error) and runs
+    // whatever partial body arrived. Download to a temp file with curl -f, then run it, so a failure stops loudly.
+    // Two lines (shell continuation) so the TUI, which clips long lines, never cuts the command short.
+    `( f=$(mktemp) && trap 'rm -f "$f"' EXIT && curl -fsSL ${b}/install -o "$f" && \\`,
+    `  sudo bash "$f" --host-id <name> )`,
+    'Self-signed certificate? Run quox fleet enrol <name>: it prints this with the certificate pinned.',
+    'Then check it arrived with: quox fleet hosts'
+  ];
+}

package/lib/quoxon/objectiveOffer.js

@@ -0,0 +1,82 @@
+/**
+ * QUOXON objective offer (owner, live 2026-10-25 19:47). Attached to SEER (advisory, no image/X/site tools) the owner asked
+ * for a blog article, an image, a publish and a tweet draft, and got "I couldn't". Offer, don't give up: the server sends
+ * turn.objective_suggested (from the turn's tool selection and the shape of the ask, never the answer text) and the TUI
+ * asks once. It REPLACES the single-turn handoff card (one ask, not two):
+ *
+ *   ⚠ SEER asks: Make this an objective that runs until done?
+ *     do     create objective "<the user's words>"; you approve the plan, then each publish/post step
+ *     why    SEER can't run x post.
+ *   ▶ Make this an objective that runs until done? y yes · n no
+ *
+ * y = `quox objective create <goal>` + start (the plan decomposes and lands as an approval card). n does nothing.
+ */
+import { askText } from './ask.js';
+
+const clipQ = (s, n) => { const t = String(s ?? '').replace(/\s+/g, ' ').trim(); return t.length > n ? `${t.slice(0, n - 1)}…` : t; };
+
+/** The suggestion from a turn event, when it applies to THIS window (attached to the agent it names). Else null. */
+export function objectiveFromEvent(ev, attachedAgent) {
+  if (!ev || ev.type !== 'turn.objective_suggested') return null;
+  const o = ev.objective_suggested;
+  const at = String(attachedAgent || '').toLowerCase();
+  if (!o || typeof o !== 'object' || !o.from || !o.goal || !at) return null;
+  if (String(o.from).toLowerCase() !== at) return null; // a suggestion about some other agent
+  const loop = o.mode === 'loop' && o.loop && Array.isArray(o.loop.capability_scope) && o.loop.capability_scope.length ? { goal_condition: String(o.loop.goal_condition || o.goal), capability_scope: o.loop.capability_scope.map(String), ...(o.loop.plain ? { plain: true } : {}), ...(Number.isInteger(o.loop.max_iterations) ? { max_iterations: o.loop.max_iterations } : {}), ...(o.loop.summary ? { summary: String(o.loop.summary) } : {}), ...(o.loop.until ? { until: String(o.loop.until) } : {}), ...(Number.isInteger(o.loop.every_seconds) ? { every_seconds: o.loop.every_seconds } : {}), ...(Number.isInteger(o.loop.max_duration_seconds) ? { max_duration_seconds: o.loop.max_duration_seconds } : {}), ...(Array.isArray(o.loop.done_check) && o.loop.done_check.length ? { done_check: o.loop.done_check } : {}) } : null; // QLOOP: a ready, engine-valid loop spec
+  return { from: at, fromName: String(o.from_name || at.toUpperCase()), goal: String(o.goal), reason: String(o.reason || '').trim(), tools: Array.isArray(o.tools) ? o.tools : [], ...(loop ? { loop } : {}) };
+}
+
+/** The ask line (drawn as the approval-style card). The goal is clipped for the card only, never in what yes creates. */
+export function objectiveAskText(o, cols = 100) {
+  if (o.loop && o.loop.plain) { // the user never said "loop": say what it does, in plain words, whole (it wraps; never clipped)
+    const mins = o.loop.max_duration_seconds ? Math.max(1, Math.round(o.loop.max_duration_seconds / 60)) : null;
+    const q = o.loop.summary ? `${o.loop.summary}?` : `This needs repeated checks: keep going until ${String(o.loop.goal_condition || o.goal).replace(/\s+/g, ' ').trim()}${mins ? `, up to ${mins} minute${mins === 1 ? '' : 's'}` : ''}?`;
+    return askText(q, { keys: 'y yes · n just once', who: o.fromName, reason: '', action: `keep going${o.loop.every_seconds ? `, checking about every ${o.loop.every_seconds} seconds,` : ''} using only ${o.loop.capability_scope.join(', ')}; you approve it before it starts` });
+  }
+  if (o.loop) return askText('Run this as a loop until it is done?', { keys: 'y/N', who: o.fromName, reason: o.reason, action: `create a loop "${clipQ(o.goal, Math.max(20, cols - 70))}" that may use only ${o.loop.capability_scope.join(', ')}; you approve it before it starts` });
+  const action = `create objective "${clipQ(o.goal, Math.max(20, cols - 60))}"; you approve the plan, then each publish/post step`;
+  return askText('Make this an objective that runs until done?', { keys: 'y/N', who: o.fromName, reason: o.reason, action });
+}
+
+export const objectiveStartedNote = (id) => `▶ Objective ${id} started. The plan will land as an approval card.`;
+export const objectiveWatchLine = (id) => `Watch it: quox objective get ${id}`;
+export const objectiveFailedNote = (goal, err) => `Objective not created: ${String(err?.message || err || 'unknown error')}. Retry: quox objective create ${JSON.stringify(goal)} --checkpoint`;
+
+// ---- report back into the conversation (owner 2026-10-26) ----
+const TERMINAL = new Set(['completed', 'completed_with_errors', 'failed', 'cancelled', 'aborted']);
+// A finished step's result is the node output JSON; its text is completion.value.
+const textOf = (r) => { const s = String(r ?? ''); if (!s.trimStart().startsWith('{')) return s; try { const o = JSON.parse(s); return typeof o?.completion?.value === 'string' ? o.completion.value : s; } catch { return s; } };
+const reportOf = (tasks) => {
+  const done = (tasks || []).filter(t => t.status === 'completed' && textOf(t.result).trim()).sort((a, b) => (a.sequence_num || 0) - (b.sequence_num || 0));
+  const pick = [...done].reverse().find(t => /report/i.test(String(t.title || ''))) || done[done.length - 1];
+  const text = pick ? textOf(pick.result).trim() : '';
+  return text.length > 1500 ? `${text.slice(0, 1499)}…` : text;
+};
+
+/** The lines the chat prints when an objective ends: the glyph line, then its report (or what did not complete). */
+export function objectiveFinishedLines(o) {
+  const tasks = Array.isArray(o.tasks) ? o.tasks : [];
+  const done = tasks.filter(t => t.status === 'completed').length;
+  const title = String(o.title || o.id || '').replace(/\s+/g, ' ').slice(0, 80);
+  const lines = [`◎ OBJECTIVE │ ${title} │ ${o.status}, ${done}/${tasks.length} steps`];
+  const report = reportOf(tasks);
+  if (report) lines.push(...report.split('\n').map(l => l.trimEnd()).filter(Boolean));
+  if (o.status !== 'completed' && o.error_message) lines.push(String(o.error_message).slice(0, 400));
+  return lines;
+}
+
+/**
+ * Poll an objective while this window is open and say how it ended. get() -> the objective with its tasks; a failed read is
+ * retried, never fatal. Resolves { finished, status }. Gives up quietly at maxMs or when stopped() (the inbox item covers a closed window).
+ */
+export async function watchObjective({ get, say, intervalMs = 8000, maxMs = 6 * 3600 * 1000, stopped = () => false } = {}) {
+  const t0 = Date.now();
+  while (Date.now() - t0 < maxMs && !stopped()) {
+    try {
+      const o = await get();
+      if (o && TERMINAL.has(o.status)) { for (const l of objectiveFinishedLines(o)) say(l); return { finished: true, status: o.status }; }
+    } catch { /* a transient read: try again */ }
+    await new Promise(r => setTimeout(r, intervalMs));
+  }
+  return { finished: false };
+}

package/lib/quoxon/objects/away.js

@@ -0,0 +1,72 @@
+/**
+ * E5 "While you were away": a factual digest since a moment, from GET /api/v1/away (collector). Every
+ * item carries the source that reported it and its time; nothing is summarised by a model. Sources the
+ * server could not read, or that went silent, come back in `blind` and are always named ("Can't see"),
+ * so an empty list never reads as an all clear it cannot vouch for.
+ */
+import { seg, fit, hhmm, plural, boxWidth, parseTs } from './model.js';
+
+/** Importance: approvals waiting first (they block work), then alerts, failures, then outcomes. */
+export const RANK = {
+  approval_waiting: 0, alert: 1, turn_failed: 2, objective_failed: 2, workflow_failed: 2,
+  approval_resolved: 3, objective_finished: 4, workflow_finished: 4, decision: 5
+};
+const GLYPH = {
+  approval_waiting: ['⚠ ', 'warn'], alert: ['⚠ ', 'warn'], turn_failed: ['✖ ', 'error'], objective_failed: ['✖ ', 'error'],
+  workflow_failed: ['✖ ', 'error'], approval_resolved: ['✔ ', 'ok'], objective_finished: ['✔ ', 'ok'],
+  workflow_finished: ['✔ ', 'ok'], decision: ['◆ ', 'indigo']
+};
+const rankOf = (it) => RANK[it?.kind] ?? 6;
+
+export function rankItems(items) {
+  return [...(items || [])].sort((a, b) => rankOf(a) - rankOf(b) || (parseTs(b.ts) ?? 0) - (parseTs(a.ts) ?? 0));
+}
+
+/** "5h", "45m", "2d" for the away window. */
+export function awayFor(sinceTs, now) {
+  const t = parseTs(sinceTs);
+  if (t == null) return '';
+  const m = Math.max(0, Math.round((now - t) / 60000));
+  if (m < 60) return `${m}m`;
+  const h = Math.round(m / 60);
+  return h < 48 ? `${h}h` : `${Math.round(h / 24)}d`;
+}
+
+/** d: { since, items, blind, activity, compact?, max?, now } */
+export function awayCard(d, cols) {
+  const now = d.now ?? Date.now();
+  const w = boxWidth(cols, 96), inner = w - 4;
+  const items = rankItems(d.items);
+  const max = d.compact ? (d.max ?? 5) : items.length;
+  const shown = items.slice(0, max);
+  const rows = [];
+  const win = awayFor(d.since, now);
+  if (!items.length) rows.push([seg(d.standing && d.standing.count > 0 ? 'Nothing new needed you.' : 'Nothing needed you.', 'muted')]);
+  for (const it of shown) {
+    const [g, role] = GLYPH[it.kind] || ['· ', 'muted'];
+    const meta = `${it.source || '?'} · ${hhmm(it.ts) || 'time unknown'}`;
+    if (d.compact) {
+      rows.push([seg(g, role), seg(fit(it.title, Math.max(8, inner - 2 - meta.length - 2)), 'value'), seg(`  ${meta}`, 'muted')]);
+    } else {
+      rows.push([seg(g, role), seg(fit(it.title, inner - 2), 'value', rankOf(it) === 0)]);
+      rows.push([seg('  '), seg(fit(meta, inner - 2), 'muted')]);
+    }
+  }
+  if (items.length > shown.length) rows.push([seg(`+${items.length - shown.length} more · /away`, 'muted')]);
+  if (d.standing && d.standing.count > 0) rows.push([seg(fit(`${plural(d.standing.count, 'older item')} still need${d.standing.count === 1 ? 's' : ''} you · quox lucid`, inner), 'muted')]);
+  const act = d.activity;
+  if (act && act.total > 0 && !d.compact) {
+    const top = (act.agents || []).slice(0, 4).map(a => `${a.agent} ${a.count}`).join(', ');
+    rows.push([seg(' ')]);
+    rows.push([seg(fit(`${act.partial ? 'at least ' : ''}${plural(act.total, 'agent action')}${top ? `: ${top}` : ''}${act.source ? ` (${act.source})` : ''}`, inner), 'muted')]);
+  }
+  const blind = d.blind || [];
+  if (blind.length && d.compact) {
+    const what = blind.map(b => (b.reason ? `${b.source} (${b.reason})` : b.source)).join(', ');
+    rows.push([seg(fit(`Can't see: ${what}`, inner), 'faint')]);
+  } else if (blind.length) {
+    rows.push([seg("Can't see:", 'faint')]);
+    for (const b of blind) rows.push([seg('  '), seg(fit(`${b.source}${b.reason ? `: ${b.reason}` : ''}`, inner - 2), 'faint')]);
+  }
+  return { box: { width: w, title: `While you were away${win ? ` (${win})` : ''}`, titleRole: 'value', right: d.compact ? '' : `since ${hhmm(d.since)}`, rightRole: 'muted', border: items.some(i => rankOf(i) === 0) ? 'warn' : 'muted' }, rows };
+}

package/lib/quoxon/objects/fetch.js

@@ -11,6 +11,12 @@ import { fileURLToPath } from 'node:url';
 import { findSkill } from '../skills.js';
 import { packFrom } from './ladder.js';
 import { slotFor } from './agent.js';
+import { listFailure } from '../session.js';
+import { resolveEndpoint } from '../../api/endpoints.js';
+import { fleetFetchers } from './fleet.js';
+import { healthFetchers } from './health.js';
+import { proveFetchers } from './prove.js';
+import { replayFetchers } from './replay.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const ASSISTANTS_DIR = path.resolve(HERE, '../../../../src/config/entities/assistants');
@@ -31,7 +37,7 @@ export function bundledIdentities(dir = ASSISTANTS_DIR) {
   return out;
 }
 
-export function createObjectsApi({ client, orgId = () => null, home = os.homedir(), identities = bundledIdentities }) {
+export function createObjectsApi({ client, orgId = () => null, home = os.homedir(), identities = bundledIdentities, profile = null }) {
   const get = (service, p, query, timeout = 12000) => client.get(p, { service, query, retries: 0, timeout });
   const post = (service, p, body, timeout = 8000) => client.post(p, { service, body, retries: 0, timeout });
   const org = () => { const o = orgId(); return typeof o === 'string' ? o : null; };
@@ -66,7 +72,11 @@ export function createObjectsApi({ client, orgId = () => null, home = os.homedir
     return out;
   }
 
-  return {
+  const self = {
+    ...fleetFetchers({ get, org, listOf, why, resolveEndpoint }),
+    ...healthFetchers({ get, org, listOf, why, resolveEndpoint }),
+    ...replayFetchers({ get, listOf, why, verifyReceipt: (id, t) => verifyReceipt(id, t), aeeGet: (id) => aeeGet(id) }),
+    ...proveFetchers({ get, listOf, resolveEndpoint, self: { proof: (t) => self.proof(t) } }),
     /** E1 */
     async skill(name) {
       const all = listOf(await get('collector', '/quoxflow/skills', { orgId: org() || undefined }), 'data', 'skills');
@@ -110,14 +120,15 @@ export function createObjectsApi({ client, orgId = () => null, home = os.homedir
     /** E4 */
     async agent(name) {
       const q = String(name || '').trim().toLowerCase();
-      let toolMap = null, toolErr = null;
-      try { toolMap = (await client.get('/api/v1/tools/agents', { service: 'collector', noAuth: true, retries: 0, timeout: 10000 }))?.agentTools || null; } catch (e) { toolErr = why(e); }
+      let toolMap = null, toolErr = null, toolFail = null;
+      try { toolMap = (await client.get('/api/v1/tools/agents', { service: 'collector', retries: 0, timeout: 10000 }))?.agentTools || null; } catch (e) { toolErr = why(e); toolFail = e; }
       let orgAgents = [];
       try { if (org()) orgAgents = listOf(await get('auth', `/api/orgs/${org()}/agents`, { includeTools: 'false' }), 'agents', 'data'); } catch { /* optional */ }
       const known = new Set([...Object.keys(toolMap || {}), ...idents().keys(), ...orgAgents.map(a => a.agent_id)]);
       let id = [...known].find(k => k.toLowerCase() === q);
       if (!id) id = [...known].find(k => String(nameOf(k)).toLowerCase() === q) || orgAgents.find(a => String(a.name || '').toLowerCase() === q)?.agent_id;
-      if (!id) return { error: `No agent called "${name}".${toolErr ? ` (agent list: ${toolErr})` : ''}`, tone: 'warn' };
+      if (!id && toolFail) return { error: `Couldn't check agents: ${listFailure(toolFail, profile)}`, tone: 'warn' }; // a failed list is a failure, never "no such agent"
+      if (!id) return { error: `No agent called "${name}".`, tone: 'warn' };
       const record = orgAgents.find(a => a.agent_id === id) || null;
       const ident = idents().get(id) || {};
       let slot = null;
@@ -167,4 +178,5 @@ export function createObjectsApi({ client, orgId = () => null, home = os.homedir
       return { data: { items } };
     }
   };
+  return self;
 }