quoxcli 0.2.0 → 0.4.0

package/lib/quoxon/objects/fleet.js

@@ -0,0 +1,149 @@
+/**
+ * /fleet: computers, agents, missions and SubFleets in one compact block, with health. Read-only.
+ * Sources (the same routes `quox fleet ...` and `quox objective list` use): GET /api/v1/agents
+ * (heartbeats), GET /api/v1/fleet/hosts (Bastion registry), org agents, GET /api/objectives. A source
+ * that could not be read is named on the "Can't see" line, never counted as zero. SubFleets have an
+ * RFC but no API yet, so that row says so. Moving work is not here: the hint points at plain words.
+ */
+import { seg, fit, fitRow, ago, plural, boxWidth } from './model.js';
+import { fromObjective } from '../roster.js';
+
+const OFFLINE = /^(dead|offline|down|disconnected|unreachable)$/;
+const HEALTHY = /^(healthy|ok|good)$/;
+const DEGRADED = /^(warning|warn|degraded|stale)$/;
+const UNHEALTHY = /^(critical|unhealthy|error|failed|fail)$/;
+const FLEET_OVERVIEW_WORDS = new Set(['health', 'status', 'list', 'all', 'overview', 'summary', 'hosts', 'agents', 'quoxagents']);
+
+export const ORDER = ['healthy', 'degraded', 'unhealthy', 'offline', 'unknown'];
+const SEVERITY = { unhealthy: 0, offline: 1, degraded: 2, unknown: 3, healthy: 4 };
+
+/** A heartbeat row or a Bastion host row -> healthy | degraded | unhealthy | offline | unknown. */
+export function healthOf(row) {
+  const s = row?.status;
+  const st = String(typeof s === 'object' && s ? s.state ?? '' : s ?? '').toLowerCase();
+  const h = String(typeof s === 'object' && s ? s.health ?? '' : '').toLowerCase();
+  if (OFFLINE.test(st) || OFFLINE.test(h)) return 'offline';
+  if (UNHEALTHY.test(h) || UNHEALTHY.test(st)) return 'unhealthy';
+  if (DEGRADED.test(h) || DEGRADED.test(st)) return 'degraded';
+  if (HEALTHY.test(h) || HEALTHY.test(st)) return 'healthy';
+  return 'unknown';
+}
+
+const listOk = (s) => (s?.ok ? s.list || [] : null);
+
+/** d: { agents, hosts, orgAgents, missions } each { ok, list } | { ok:false, error } -> merged view model. */
+export function collectFleet(d, now = Date.now()) {
+  const byId = new Map();
+  const cant = [];
+  const sources = [['heartbeats', d.agents], ['hosts', d.hosts]];
+  for (const [label, src] of sources) {
+    if (!src) continue;
+    if (!src.ok) { cant.push(`${label} (${src.error || 'failed'})`); continue; }
+    for (const r of src.list || []) {
+      const id = r.host_id || r.id || r.hostname;
+      if (!id) continue;
+      const cur = byId.get(id) || { id };
+      if (label === 'heartbeats') {
+        const s = r.status;
+        byId.set(id, { ...cur, health: healthOf(r), version: r.version ?? cur.version, lastSeenS: typeof s === 'object' ? s?.last_seen_seconds : undefined, heartbeat: true });
+      } else {
+        byId.set(id, { ...cur, ip: r.ip ?? cur.ip, group: r.group ?? cur.group, registryHealth: healthOf(r), health: cur.heartbeat ? cur.health : healthOf(r) });
+      }
+    }
+  }
+  const computers = [...byId.values()].sort((a, b) => SEVERITY[a.health] - SEVERITY[b.health] || a.id.localeCompare(b.id));
+  const counts = Object.fromEntries(ORDER.map(k => [k, 0]));
+  for (const c of computers) counts[c.health]++;
+  const org = listOk(d.orgAgents);
+  if (d.orgAgents && !d.orgAgents.ok) cant.push(`agents (${d.orgAgents.error || 'failed'})`);
+  const agents = org ? { active: org.filter(a => !a.status || a.status === 'active').length, other: org.filter(a => a.status && a.status !== 'active').length } : null;
+  let missions = null;
+  if (d.missions && !d.missions.ok) cant.push(`missions (${d.missions.error || 'failed'})`);
+  else if (d.missions) {
+    const rows = (d.missions.list || []).map(o => fromObjective(o, now)).filter(Boolean);
+    missions = { running: rows.filter(r => r.state === 'running').length, waiting: rows.filter(r => r.state === 'waiting').length, loops: rows.filter(r => r.kind === 'loop' && (r.state === 'running' || r.state === 'waiting')).length, rows: rows.filter(r => r.state === 'running' || r.state === 'waiting') };
+  }
+  return { computers, counts, agents, missions, cant };
+}
+
+const ROLE = { healthy: 'ok', degraded: 'warn', unhealthy: 'error', offline: 'error', unknown: 'muted' };
+const HINT = 'ask in plain words to move work';
+
+/** d: { agents, hosts, orgAgents, missions, now } -> view { box, rows } */
+export function fleetCard(d, cols) {
+  const now = d.now ?? Date.now();
+  const f = collectFleet(d, now);
+  const w = boxWidth(cols, 78), inner = w - 4;
+  const L = (label, parts) => [seg(label.padEnd(12), 'muted'), ...parts];
+  const rows = [];
+  if (f.computers.length || (d.agents?.ok || d.hosts?.ok)) {
+    const bits = [];
+    for (const k of ORDER) if (f.counts[k]) { if (bits.length) bits.push(seg(' · ', 'muted')); bits.push(seg(`${f.counts[k]} ${k}`, ROLE[k], k !== 'healthy')); }
+    rows.push(L('Computers', [seg(`${f.computers.length}  `, 'value', true), ...bits]));
+    const bad = f.computers.filter(c => c.health !== 'healthy');
+    if (bad.length) rows.push([seg('not healthy'.padEnd(12), 'muted'), seg(fit(bad.map(c => `${c.id} ${c.health}`).join(', '), inner - 12), 'warn')]);
+  } else rows.push(L('Computers', [seg('?', 'warn'), seg(' not read', 'muted')]));
+  rows.push(f.agents ? L('Agents', [seg(`${f.agents.active} active`, 'value'), ...(f.agents.other ? [seg(` · ${f.agents.other} other`, 'muted')] : [])]) : L('Agents', [seg('?', 'warn')]));
+  if (f.missions) {
+    const m = f.missions;
+    const extra = [m.waiting ? plural(m.waiting, 'waiting', 'waiting') : null, m.loops ? plural(m.loops, 'loop') : null].filter(Boolean);
+    rows.push(L('Missions', [seg(`${m.running} running`, 'value'), ...(extra.length ? [seg(` · ${extra.join(' · ')}`, 'muted')] : [])]));
+    for (const r of m.rows.slice(0, 3)) rows.push([seg('  ', 'muted'), seg(fit(`${r.name}${r.activity ? ` · ${r.activity}` : ''}`, inner - 2), 'muted')]);
+    if (m.rows.length > 3) rows.push([seg(`  …and ${m.rows.length - 3} more`, 'muted')]);
+  } else rows.push(L('Missions', [seg('?', 'warn')]));
+  rows.push(L('SubFleets', [seg('none yet', 'muted'), seg(w < 60 ? '' : ' (designed, no API in this Quox)', 'muted')]));
+  if (f.cant.length) rows.push([seg("Can't see ", 'warn'), seg(fit(f.cant.join(', '), inner - 12), 'warn')]);
+  rows.push([seg(HINT, 'muted')]);
+  return { box: { width: w, title: 'Fleet', titleRole: 'sky', border: 'sky' }, rows: rows.map(r => fitRow(r, inner)) };
+}
+
+/** d: { host, now } -> view for one computer. */
+export function hostCard(d, cols) {
+  const h = d.host;
+  const w = boxWidth(cols, 66), inner = w - 4;
+  const L = (label, v, role = 'value') => [seg(label.padEnd(8), 'muted'), seg(fit(v, inner - 8), role)];
+  const rows = [L('health', h.health, ROLE[h.health])];
+  if (h.ip) rows.push(L('ip', h.ip));
+  if (h.group) rows.push(L('group', h.group));
+  if (h.version) rows.push(L('version', h.version));
+  if (typeof h.lastSeenS === 'number') rows.push(L('seen', `${ago(Date.now() - h.lastSeenS * 1000, Date.now()) || '0s'} ago`, 'muted'));
+  if (!h.heartbeat) rows.push(L('agent', 'no heartbeat (in the registry only)', 'muted'));
+  rows.push([seg(HINT, 'muted')]);
+  return { box: { width: w, title: h.id, titleRole: 'sky', right: h.health, rightRole: ROLE[h.health], border: 'sky' }, rows };
+}
+
+/** Builder registered as BUILDERS.fleet: one host when d.host is set, else the whole fleet. */
+export function fleetView(d, cols) { return d.host ? hostCard(d, cols) : fleetCard(d, cols); }
+
+/** Fetchers for createObjectsApi (kept here so fetch.js only spreads them in). */
+export function fleetFetchers({ get, org, listOf, why, resolveEndpoint }) {
+  const read = async (fn) => { try { return { ok: true, list: await fn() }; } catch (e) { return { ok: false, error: why(e) }; } };
+  return {
+    /** Host ids for /fleet <TAB>: [{ value, desc }]; a failed read suggests nothing. */
+    async fleetNames() {
+      const hb = resolveEndpoint('v1.agents.list');
+      const rows = listOf(await get(hb.service, hb.path, undefined, 6000), 'agents');
+      return rows.map(r => r.host_id || r.id).filter(Boolean).map(id => ({ value: String(id), desc: healthOf(rows.find(r => (r.host_id || r.id) === id)) }));
+    },
+    /** E-fleet: name '' = the whole fleet, else one computer by id (case-insensitive, then prefix). */
+    async fleet(name) {
+      const q = String(name || '').trim().toLowerCase();
+      const hb = resolveEndpoint('v1.agents.list'), hs = resolveEndpoint('v1.fleet.hosts.list'), ob = resolveEndpoint('objectives.list');
+      const [agents, hosts, orgAgents, missions] = await Promise.all([
+        read(async () => listOf(await get(hb.service, hb.path, undefined, 10000), 'agents')),
+        read(async () => listOf(await get(hs.service, hs.path, undefined, 10000), 'hosts')),
+        org() ? read(async () => { const ep = resolveEndpoint('agents.list', { orgId: org() }); return listOf(await get(ep.service, ep.path, { includeTools: 'false' }, 10000), 'agents', 'data'); }) : Promise.resolve(null),
+        read(async () => listOf(await get(ob.service, ob.path, { limit: 100 }, 10000), 'objectives'))
+      ]);
+      const data = { agents, hosts, orgAgents, missions, now: Date.now() };
+      if (!q) return { data };
+      const f = collectFleet(data, data.now);
+      const host = f.computers.find(c => c.id.toLowerCase() === q) || f.computers.find(c => c.id.toLowerCase().startsWith(q));
+      if (host) return { data: { host, now: data.now } };
+      // owner 2026-10-15 typed "/fleet health": overview words mean the whole fleet (a real host by that name still wins above)
+      if (FLEET_OVERVIEW_WORDS.has(q)) return { data };
+      if (!agents.ok && !hosts.ok) return { error: `Couldn't check hosts: ${agents.error}.`, tone: 'warn' }; // a failed list is never "no such host"
+      return { error: `No host called "${name}". /fleet lists them.`, tone: 'warn' };
+    }
+  };
+}

package/lib/quoxon/objects/health.js

@@ -0,0 +1,186 @@
+/**
+ * /health (and /core): a compact summary of what the Core dashboard's overview (/dashboard) shows.
+ * Read-only, no model call, server-side reads only (the same truth the dashboard reads):
+ *   services   GET collector /api/v1/health/aggregate (the dashboard's service ring)
+ *   computers  GET /api/v1/agents heartbeats + GET /api/v1/fleet/hosts (as /fleet)
+ *   agents     org agents (as /fleet)
+ *   approvals  GET auth /api/orgs/:org/inbox/stats (the dashboard's "Attention needed")
+ *   missions   GET tasks /api/objectives (the dashboard's live objectives)
+ *   failures   GET quoxflow /api/executions?status=failed&since=24h
+ *   licence    GET auth /api/setup/licensing/entitlements
+ * A section whose read failed says "unavailable: <reason>"; an error body is never shown as zero.
+ * /status stays the session panel; /collector-health still goes to /status.
+ */
+import { seg, fit, fitRow, plural, boxWidth } from './model.js';
+import { collectFleet, fleetFetchers } from './fleet.js';
+
+const DAY_MS = 24 * 3600 * 1000;
+const SVC_ROLE = { ok: 'ok', degraded: 'warn', down: 'error' };
+const reasons = (...srcs) => [...new Set(srcs.filter(s => s && !s.ok).map(s => s.error || 'failed'))].join(', ');
+
+/** d: { aggregate, agents, hosts, orgAgents, missions, inbox, failures, licence, now } -> per-section model ({ error } when unread). */
+export function collectHealth(d) {
+  const now = d.now ?? Date.now();
+  const out = {};
+
+  const a = d.aggregate;
+  if (!a?.ok) out.services = { error: a?.error || 'not read' };
+  else {
+    const all = Object.entries(a.data?.services || {});
+    // Z2H run-6: an optional service this install does not ship (collector says not_installed) is neither up nor down.
+    const entries = all.filter(([, s]) => s?.status !== 'not_installed');
+    out.services = {
+      up: entries.filter(([, s]) => s?.status === 'ok').length,
+      total: entries.length,
+      score: typeof a.data?.score === 'number' ? a.data.score : null,
+      bad: entries.filter(([, s]) => s?.status !== 'ok').map(([name, s]) => ({ name, status: s?.status || 'unknown' })),
+      notInstalled: all.filter(([, s]) => s?.status === 'not_installed').map(([name]) => name),
+    };
+  }
+
+  const f = collectFleet({ agents: d.agents, hosts: d.hosts, orgAgents: d.orgAgents, missions: d.missions }, now);
+  if (d.agents?.ok || d.hosts?.ok) {
+    out.computers = { healthy: f.counts.healthy, total: f.computers.length, bad: f.computers.filter(c => c.health !== 'healthy').map(c => ({ id: c.id, health: c.health })), partial: reasons(d.agents, d.hosts) || null };
+  } else out.computers = { error: reasons(d.agents, d.hosts) || 'not read' };
+
+  if (!d.orgAgents) out.agents = { error: 'no org selected' };
+  else out.agents = f.agents ? { ...f.agents } : { error: d.orgAgents.error || 'failed' };
+
+  out.missions = f.missions ? { running: f.missions.running, waiting: f.missions.waiting, loops: f.missions.loops } : { error: d.missions?.error || 'not read' };
+
+  const ib = d.inbox;
+  if (!ib?.ok) out.approvals = { error: ib?.error || 'not read' };
+  else {
+    const s = ib.data || {};
+    out.approvals = { approvals: Number(s.pending_approvals) || 0, active: Number(s.total_active) || 0, urgent: Number(s.urgent) || 0, overdue: Number(s.overdue) || 0 };
+  }
+
+  const fl = d.failures;
+  if (!fl?.ok) out.failures = { error: fl?.error || 'not read' };
+  else {
+    const list = fl.list || [];
+    const r = list[0];
+    out.failures = { count: typeof fl.total === 'number' ? fl.total : list.length, last: r ? (r.workflowName || r.workflow_name || r.name || r.workflowId || r.workflow_id || r.id || null) : null };
+  }
+
+  const li = d.licence;
+  if (!li?.ok) out.licence = { error: li?.error || 'not read' };
+  else {
+    const L = li.data || {};
+    const leases = Array.isArray(L.licenses) ? L.licenses : [];
+    const plugins = Array.isArray(L.entitlements) ? L.entitlements.length : 0;
+    const errors = Array.isArray(L.entitlement_errors) ? L.entitlement_errors.length : 0;
+    if (!leases.length) out.licence = { core: true, plugins, errors };
+    else {
+      const plans = [...new Set(leases.flatMap(x => Array.isArray(x.plans) ? x.plans : []))];
+      const exp = leases.map(x => Date.parse(x.expires_at)).filter(Number.isFinite).sort((x, y) => x - y)[0];
+      out.licence = { core: false, plans, plugins, errors, expiresAt: Number.isFinite(exp) ? exp : null, expired: Number.isFinite(exp) && exp < now };
+    }
+  }
+  return out;
+}
+
+/** Overall verdict for the title: partial (a section unread) > needs attention > all good. */
+function verdict(h) {
+  if (Object.values(h).some(s => s?.error)) return ['partial', 'warn'];
+  const attention = h.services.up < h.services.total || h.computers.bad.length || h.failures.count || h.approvals.approvals || h.approvals.urgent || h.approvals.overdue || h.licence.errors || h.licence.expired;
+  return attention ? ['needs attention', 'warn'] : ['all good', 'ok'];
+}
+
+const HINT = [seg('/fleet', 'key'), seg(' computers · ', 'label'), seg('/status', 'key'), seg(' this session · ', 'label'), seg('/dashboard', 'key'), seg(' open it', 'label')];
+
+/** d -> view { box, rows }. */
+export function healthCard(d, cols) {
+  const h = collectHealth(d);
+  const w = boxWidth(cols, 78), inner = w - 4;
+  const L = (label, parts) => [seg(label.padEnd(11), 'label'), ...parts];
+  const na = (s) => [seg('unavailable: ', 'warn'), seg(s.error, 'warn')];
+  const sep = () => seg(' · ', 'label');
+  const rows = [];
+
+  const s = h.services;
+  if (s.error) rows.push(L('Services', na(s)));
+  else {
+    const parts = [seg(`${s.up}/${s.total} up`, s.up === s.total ? 'ok' : 'warn', true)];
+    for (const b of s.bad) parts.push(sep(), seg(`${b.name} ${b.status}`, SVC_ROLE[b.status] || 'warn'));
+    for (const n of s.notInstalled || []) parts.push(sep(), seg(`${n} not installed`, 'value'));
+    rows.push(L('Services', parts));
+  }
+
+  const c = h.computers;
+  if (c.error) rows.push(L('Computers', na(c)));
+  else if (!c.total) rows.push(L('Computers', [seg('none connected', 'value')]));
+  else {
+    const parts = [seg(`${c.healthy}/${c.total} healthy`, c.healthy === c.total ? 'ok' : 'warn', true)];
+    if (c.bad.length) parts.push(sep(), seg(fit(c.bad.map(x => `${x.id} ${x.health}`).join(', '), inner), c.bad.some(x => x.health === 'offline' || x.health === 'unhealthy') ? 'error' : 'warn'));
+    if (c.partial) parts.push(sep(), seg(`partial: ${c.partial}`, 'warn'));
+    rows.push(L('Computers', parts));
+  }
+
+  const ag = h.agents;
+  rows.push(L('Agents', ag.error ? na(ag) : [seg(`${ag.active} active`, 'value', true), ...(ag.other ? [sep(), seg(`${ag.other} other`, 'value')] : [])]));
+
+  const ap = h.approvals;
+  if (ap.error) rows.push(L('Approvals', na(ap)));
+  else {
+    const parts = [seg(ap.approvals ? `${ap.approvals} open` : 'none open', ap.approvals ? 'warn' : 'ok', true)];
+    if (ap.active) parts.push(sep(), seg(`${ap.active} in inbox`, 'value'));
+    if (ap.urgent) parts.push(sep(), seg(`${ap.urgent} urgent`, 'error'));
+    if (ap.overdue) parts.push(sep(), seg(`${ap.overdue} overdue`, 'error'));
+    rows.push(L('Approvals', parts));
+  }
+
+  const m = h.missions;
+  if (m.error) rows.push(L('Missions', na(m)));
+  else {
+    const parts = [seg(`${m.running} running`, 'value', true)];
+    if (m.waiting) parts.push(sep(), seg(`${m.waiting} waiting`, 'warn'));
+    if (m.loops) parts.push(sep(), seg(plural(m.loops, 'loop'), 'value'));
+    rows.push(L('Missions', parts));
+  }
+
+  const fl = h.failures;
+  if (fl.error) rows.push(L('Failures', na(fl)));
+  else if (!fl.count) rows.push(L('Failures', [seg('none in 24h', 'ok')]));
+  else rows.push(L('Failures', [seg(`${plural(fl.count, 'failed run')} in 24h`, 'error', true), ...(fl.last ? [sep(), seg(`last: ${fl.last}`, 'value')] : [])]));
+
+  const li = h.licence;
+  if (li.error) rows.push(L('Licence', na(li)));
+  else {
+    const parts = li.core ? [seg('Core (free)', 'value', true)] : [seg(li.plans.length ? li.plans.join(', ') : 'licensed', 'value', true)];
+    if (li.plugins) parts.push(sep(), seg(plural(li.plugins, 'plugin'), 'value'));
+    if (!li.core && li.expiresAt) parts.push(sep(), seg(li.expired ? `expired ${new Date(li.expiresAt).toISOString().slice(0, 10)}` : `until ${new Date(li.expiresAt).toISOString().slice(0, 10)}`, li.expired ? 'error' : 'value'));
+    if (li.errors) parts.push(sep(), seg(plural(li.errors, 'licence error'), 'error'));
+    rows.push(L('Licence', parts));
+  }
+
+  rows.push(HINT);
+  const [right, rightRole] = verdict(h);
+  return { box: { width: w, title: 'Health', titleRole: 'sky', right, rightRole, border: 'sky' }, rows: rows.map(r => fitRow(r, inner)) };
+}
+
+/** Fetchers for createObjectsApi. Every read is bounded and every failure carries its reason. */
+export function healthFetchers({ get, org, listOf, why, resolveEndpoint }) {
+  const fleet = fleetFetchers({ get, org, listOf, why, resolveEndpoint });
+  const read = async (fn) => { try { return { ok: true, ...(await fn()) }; } catch (e) { return { ok: false, error: why(e) }; } };
+  const noOrg = { ok: false, error: 'no org selected' };
+  return {
+    /** -> { data } for the health card (now injectable for tests). */
+    async health(now = Date.now()) {
+      const ag = resolveEndpoint('v1.health.aggregate.list'), ex = resolveEndpoint('executions.list'), lic = resolveEndpoint('setup.licensing.entitlements.list');
+      const o = org();
+      const [fl, aggregate, inbox, failures, licence] = await Promise.all([
+        fleet.fleet(''),
+        read(async () => ({ data: await get(ag.service, ag.path, undefined, 15000) })),
+        o ? read(async () => { const ep = resolveEndpoint('inbox.stats.list', { orgId: o }); return { data: await get(ep.service, ep.path, undefined, 8000) }; }) : Promise.resolve(noOrg),
+        read(async () => {
+          const d = await get(ex.service, ex.path, { status: 'failed', since: new Date(now - DAY_MS).toISOString(), limit: 5 }, 8000);
+          const total = d?.pagination?.total;
+          return { list: listOf(d, 'data', 'executions'), total: typeof total === 'number' ? total : undefined };
+        }),
+        read(async () => ({ data: await get(lic.service, lic.path, undefined, 8000) })),
+      ]);
+      return { data: { ...fl.data, aggregate, inbox, failures, licence, now } };
+    }
+  };
+}

package/lib/quoxon/objects/index.js

@@ -11,12 +11,21 @@ import { agentCard } from './agent.js';
 import { memoryFacts } from './memory.js';
 import { rulesLadder } from './ladder.js';
 import { proofChain, reconcileView } from './proof.js';
+import { wrapHang } from './model.js';
+import { awayCard } from './away.js';
+import { sitrepCard } from './sitrep.js';
+import { fleetView } from './fleet.js';
+import { healthCard } from './health.js';
+import { proveView, lastTurnCalls } from './prove.js';
+import { replayView, parseReplayArg } from './replay.js';
+import { mirrorCard } from './mirror.js';
+import { peekCard } from './peek.js';
 
-export { skillCard, stepFlow, crystalCard, agentCard, memoryFacts, rulesLadder, proofChain, reconcileView };
+export { skillCard, stepFlow, crystalCard, agentCard, memoryFacts, rulesLadder, proofChain, reconcileView, awayCard, sitrepCard };
 export { createObjectsApi } from './fetch.js';
 export { decodeRow, arrivalSeconds } from './model.js';
 
-export const BUILDERS = { skill: skillCard, workflow: stepFlow, crystal: crystalCard, agent: agentCard, memory: memoryFacts, rules: rulesLadder, proof: proofChain, reconcile: reconcileView };
+export const BUILDERS = { skill: skillCard, workflow: stepFlow, crystal: crystalCard, agent: agentCard, memory: memoryFacts, rules: rulesLadder, proof: proofChain, reconcile: reconcileView, away: awayCard, sitrep: sitrepCard, fleet: fleetView, health: healthCard, prove: proveView, replay: replayView, mirror: mirrorCard, peek: peekCard };
 
 /** -> view { box?, rows } for an object item at this width (now injected for tests). */
 export function buildObject(obj, cols, now = Date.now()) {
@@ -46,7 +55,8 @@ export async function runObjectCommand(cmd, arg, ctx) {
   const o = ctx.objects;
   const a = String(arg || '').trim();
   // A bare /skills or /agents is a list, not an object: leave it to its own handler.
-  if (!['/workflow', '/crystal', '/memory', '/rules', '/proof', '/reconcile'].includes(cmd) && !((cmd === '/skills' || cmd === '/agents') && a)) return null;
+  if (!['/workflow', '/crystal', '/memory', '/rules', '/proof', '/reconcile', '/fleet', '/prove', '/replay', '/health', '/core'].includes(cmd) && !((cmd === '/skills' || cmd === '/agents') && a)) return null;
+  if (!o?.health && (cmd === '/health' || cmd === '/core')) return null; // no objects api (demo, local): app.js shows /status instead
   if (!o) return cmd === '/rules' || cmd === '/skills' ? null : { note: 'Object views are not available in this mode.', tone: 'warn' };
   const wrap = async (type, fn) => {
     try {
@@ -63,6 +73,18 @@ export async function runObjectCommand(cmd, arg, ctx) {
     case '/workflow': return a ? wrap('workflow', () => o.workflowRun(a)) : { note: USAGE['/workflow'], tone: 'warn' };
     case '/crystal': return a ? wrap('crystal', () => o.crystal(a)) : { note: USAGE['/crystal'], tone: 'warn' };
     case '/memory': return a ? wrap('memory', () => o.memory(a)) : { note: USAGE['/memory'], tone: 'warn' };
+    case '/replay': {
+      const { ref, page } = parseReplayArg(a);
+      if (!ref && !ctx.conversationId && !toolCalls(ctx.items).length) return { note: 'Nothing to replay yet: no turn in this conversation. /replay <run or conversation id> replays an earlier one.' };
+      return wrap('replay', () => o.replay({ ref, page, conversationId: ctx.conversationId || null, calls: lastTurnCalls(ctx.items) }));
+    }
+    case '/prove': {
+      const calls = lastTurnCalls(ctx.items);
+      if (!calls.length) return { note: 'No tool calls in the last turn: nothing to prove.' };
+      return wrap('prove', () => o.prove(calls));
+    }
+    case '/fleet': return wrap('fleet', () => o.fleet(a));
+    case '/health': case '/core': return wrap('health', () => o.health()); // the Core dashboard summary (objects/health.js)
     case '/rules': {
       return wrap('rules', async () => {
         const r = await o.rules();
@@ -70,10 +92,27 @@ export async function runObjectCommand(cmd, arg, ctx) {
       });
     }
     case '/proof': {
-      const calls = toolCalls(ctx.items).filter(b => b.envelopeId);
-      const t = a ? calls.find(b => b.envelopeId === a || b.callId === a) : calls[calls.length - 1];
-      if (!t) return { note: a ? `No tool call "${a}" with an envelope in this session.` : 'No tool call with an envelope id in this session yet.', tone: 'warn' };
-      return wrap('proof', () => o.proof({ tool: t.tool, status: t.status, envelopeId: t.envelopeId, callId: t.callId }));
+      const all = toolCalls(ctx.items);
+      const calls = all.filter(b => b.envelopeId);
+      const newest = [...calls].reverse(); // 1 = newest
+      const num = /^\d{1,3}$/.test(a) ? Number(a) : 0;
+      const pick = (b) => wrap('proof', () => o.proof({ tool: b.tool, status: b.status, envelopeId: b.envelopeId, callId: b.callId }));
+      if (num >= 1 && newest[num - 1]) return pick(newest[num - 1]);
+      const t = a && !num ? calls.find(b => b.envelopeId === a || b.callId === a) : (calls.length === 1 ? calls[0] : null);
+      if (t) return pick(t);
+      if (a) return { note: `No tool call "${a}" with an envelope in this session. /proof lists them; /evidence exports the whole conversation.`, tone: 'warn' };
+      if (!calls.length) {
+        const ran = all.length ? ` ${all.length} tool call${all.length === 1 ? '' : 's'} ran, but the server reported no envelope id for ${all.length === 1 ? 'it' : 'them'}.` : '';
+        return { note: `No tool call with an envelope id in this session yet.${ran} /evidence exports what the server filed for this conversation.`, tone: 'warn' };
+      }
+      // Several calls: list the envelope ids, newest first (ten), then how many more.
+      const shown = newest.slice(0, 10);
+      const W = Math.max(20, (ctx.cols || 1e9) - 4);
+      const lines = [...wrapHang(`${calls.length} tool call${calls.length === 1 ? '' : 's'} with an envelope in this conversation (newest first):`, W, 2),
+        ...shown.flatMap((b, i) => wrapHang(`  ${i + 1}. ${b.envelopeId}  ${b.tool || 'tool'} ${b.status || ''}`.trimEnd(), W, 5))];
+      if (newest.length > shown.length) lines.push(`  ${newest.length - shown.length} more (older)`);
+      lines.push(...wrapHang('/proof <number or id> shows one chain. /evidence exports the signed bundle of all of them.', W, 2));
+      return { note: lines.join('\n'), lines, tone: 'dim' };
     }
     case '/reconcile': {
       const unk = toolCalls(ctx.items).filter(b => b.status === 'effect_unknown');

package/lib/quoxon/objects/mirror.js

@@ -0,0 +1,137 @@
+/**
+ * /mirror: the Mirror, what CommanderQ sees about this org right now. Read from GET /api/v1/mind/mirror,
+ * the org-scoped object the collector builds from each owning service and injects into CommanderQ's
+ * [SELF-KNOWLEDGE]. Sectioned: identity, health, implants, capabilities, plugins, memory, codebase,
+ * then every unknown with its code, service and message. `/mirror agents` lists the agents.
+ * Text wraps to width, never clipped. No grey roles: 'value' text, 'sky' headings, 'ok'/'warn' state.
+ */
+import { seg, boxWidth, len } from './model.js';
+
+const age = (ms) => {
+  if (!Number.isFinite(ms)) return '';
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  return h < 48 ? `${h}h` : `${Math.floor(h / 24)}d`;
+};
+
+/** Word-wrap to n display chars; a word longer than n is hard-split. Nothing is dropped. */
+export function wrapText(text, n) {
+  const out = [];
+  for (const para of String(text ?? '').split('\n')) {
+    let line = '';
+    for (let w of para.split(/\s+/).filter(Boolean)) {
+      while (len(w) > n) {
+        if (line) { out.push(line); line = ''; }
+        out.push([...w].slice(0, n).join('')); w = [...w].slice(n).join('');
+      }
+      if (!line) line = w;
+      else if (len(line) + 1 + len(w) <= n) line += ' ' + w;
+      else { out.push(line); line = w; }
+    }
+    out.push(line);
+  }
+  return out;
+}
+
+const ICON = { healthy: '✔', degraded: '⚠', weak: '⚠', collecting: '◐', 'license-required': '⛔', unreachable: '✖', 'not-reported': '◐' };
+const unk = (u) => `unknown: ${u.code} (${u.service}: ${u.message})`;
+const isUnk = (v) => v && typeof v === 'object' && v.unknown;
+
+/** d: GET /api/v1/mind/mirror body (+ view: 'agents'). -> view { box, rows } */
+export function mirrorCard(d, cols) {
+  const w = boxWidth(cols, 100), inner = w - 4;
+  const rows = [];
+  const put = (t, role = 'value', indent = 0) => { const pad = ' '.repeat(indent); for (const l of wrapText(t, inner - indent)) rows.push([seg(pad + l, role)]); };
+  const head = (t) => { if (rows.length) rows.push([seg(' ')]); rows.push([seg(t, 'sky', true)]); };
+  const m = d?.mirror;
+  const a = age(d?.age_ms);
+  const right = `${a ? `${a} old · ` : ''}${d?.fresh ? 'fresh' : 'stale'}`;
+  const box = (title) => ({ width: w, title, titleRole: 'value', right, rightRole: d?.fresh ? 'ok' : 'warn', border: d?.fresh ? 'indigo' : 'warn' });
+  if (!m) {
+    put(`The Mirror could not be read: ${d?.error || d?.reason || 'the server returned no mirror'}.`, 'warn'); // RESTORE-TUI: say the server's reason (an unbuilt mirror says why)
+    return { box: { ...box('The Mirror'), right: 'not available', rightRole: 'warn', border: 'warn' }, rows };
+  }
+
+  if (d.view === 'agents') {
+    const ag = m.capabilities?.agents;
+    if (isUnk(ag)) put(`Agents ${unk(ag.unknown)}`, 'warn');
+    else {
+      put(`${ag.count} agents, ${ag.entitled} entitled for this org.`);
+      rows.push([seg(' ')]);
+      for (const x of ag.list || []) put(`${x.entitled === false ? '⛔' : '✔'} ${x.name || x.id} (${x.id})${x.role ? ` · ${x.role}` : ''}${x.level != null ? ` · level ${x.level}` : ''}${x.entitled === false ? ' · not entitled' : ''}`, x.entitled === false ? 'warn' : 'value');
+    }
+    return { box: box('The Mirror · agents'), rows };
+  }
+
+  head('Identity');
+  put(`${m.identity?.name || 'CommanderQ'}: ${m.identity?.role || ''}. This is what CommanderQ is told about this org on every turn, built ${m.generatedAt || 'now'} from server reads.`);
+
+  head('Health');
+  if (isUnk(m.health)) put(unk(m.health.unknown), 'warn');
+  else {
+    const h = m.health;
+    put(`${h.score}% · ${h.activeServices}/${h.totalServices} services up${h.down?.length ? ` · down: ${h.down.join(', ')}` : ''}${h.degraded?.length ? ` · degraded: ${h.degraded.join(', ')}` : ''}`, h.score >= 90 ? 'ok' : 'warn');
+  }
+
+  head('Implants');
+  if (isUnk(m.implants)) put(unk(m.implants.unknown), 'warn');
+  else {
+    const s = m.implantSummary;
+    if (s) put(`${s.healthy}/${s.total} healthy (${Object.entries(s.by_status || {}).map(([k, v]) => `${v} ${k}`).join(', ')})`);
+    for (const i of m.implants || []) {
+      const bad = i.status !== 'healthy';
+      put(`${ICON[i.status] || '◐'} ${i.name}${i.tier ? ` [${i.tier}]` : ''} · ${i.status}${typeof i.health === 'number' ? ` ${i.health}` : ''}${i.metric ? ` · ${i.metric}` : ''}`, bad ? 'warn' : 'value', 1);
+      if (i.reason && bad) put(`${i.reason.code} (${i.reason.service}: ${i.reason.message})`, 'warn', 4);
+    }
+  }
+
+  head('Capabilities');
+  const c = m.capabilities || {};
+  put(isUnk(c.tools) ? `Tools ${unk(c.tools.unknown)}` : `Tools: ${c.tools.total} (${c.tools.platform} platform, ${c.tools.org} installed for this org)`, isUnk(c.tools) ? 'warn' : 'value');
+  put(isUnk(c.workflows) ? `Workflows ${unk(c.workflows.unknown)}` : `Workflows: ${c.workflows}`, isUnk(c.workflows) ? 'warn' : 'value');
+  put(isUnk(c.agents) ? `Agents ${unk(c.agents.unknown)}` : `Agents: ${c.agents.count} (${c.agents.entitled} entitled) · /mirror agents lists them`, isUnk(c.agents) ? 'warn' : 'value');
+
+  head('Plugins');
+  if (isUnk(m.plugins)) put(unk(m.plugins.unknown), 'warn');
+  else put(`${m.plugins.installed} installed, ${m.plugins.enabled} enabled${m.plugins.list?.length ? `: ${m.plugins.list.map((p) => p.id).join(', ')}` : ''}`);
+
+  head('Memory');
+  if (isUnk(m.memory)) put(unk(m.memory.unknown), 'warn');
+  else {
+    const mm = m.memory;
+    put(`${mm.total} memories, ${mm.entities} entities, ${mm.relations} relations, across ${mm.users} users of this org`);
+    const types = Object.entries(mm.by_type || {}).sort((x, y) => y[1] - x[1]);
+    if (types.length) put(types.map(([k, v]) => `${k} ${v}`).join(' · '), 'value', 1);
+  }
+
+  head('Codebase');
+  const f = m.codebaseFabric || {};
+  if (isUnk(f)) put(unk(f.unknown), 'warn');
+  else {
+    if (f.repobrain_unknown) put(`RepoBrain ${unk(f.repobrain_unknown)}`, 'warn');
+    else {
+      put(`RepoBrain: ${f.repos} repos indexed${f.indexedFiles != null ? `, ${f.indexedFiles} files` : ''}`);
+      if (f.indexedFiles_reason) put(`files ${f.indexedFiles_reason.code} (${f.indexedFiles_reason.service}: ${f.indexedFiles_reason.message})`, 'warn', 1);
+    }
+    if (f.projects_unknown) put(`Scans ${unk(f.projects_unknown)}`, 'warn');
+    else if (f.projectCount != null) put(`Scans: ${f.projectCount} projects, ${f.totalRoutes} routes, ${f.totalServices} services, invariants ${f.invariantStatus}${f.lastScan ? `, last ${f.lastScan}` : ''}`);
+    if (f.lastScan_reason) put(`${f.lastScan_reason.code} (${f.lastScan_reason.service}: ${f.lastScan_reason.message})`, 'warn', 1);
+  }
+
+  const un = m.unknowns || [];
+  head(`Unknown (${un.length})`);
+  if (!un.length) put('Every section above was read from its service.', 'ok');
+  for (const u of un) put(`${u.section}: ${u.code} (${u.service}: ${u.message})`, 'warn');
+  return { box: box('The Mirror'), rows };
+}
+
+/** A failed fetch as one plain line: the HTTP status, the error code and the server's own reason. */
+export function mirrorErrorNote(e) {
+  const body = e?.body && typeof e.body === 'object' ? e.body : {};
+  const reason = body.error || body.message || e?.message || 'failed';
+  const code = body.code || (typeof e?.code === 'string' ? e.code : '');
+  return `mirror: could not read the Mirror (${e?.status ? `HTTP ${e.status}: ` : ''}${code ? `${code}: ` : ''}${reason}). Nothing is assumed.`;
+}

package/lib/quoxon/objects/model.js

@@ -21,6 +21,39 @@ export const fit = (s, n) => {
   return g.length > n ? g.slice(0, Math.max(0, n - 1)).join('') + '…' : g.join('');
 };
 
+/**
+ * Wrap a string to `width` display chars, never clipping: breaks at spaces, indents each continuation by `hang`
+ * spaces beyond the line's own leading indent, and hard-splits a token longer than the line (an id stays whole
+ * across rows, no ellipsis). -> string[]
+ */
+export function wrapHang(text, width, hang = 4) {
+  const src = String(text ?? '');
+  const lead = (src.match(/^ */) || [''])[0];
+  const words = src.trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return [src];
+  const w = Math.max(8, width);
+  const lines = [];
+  let cur = lead;
+  let curHas = false;
+  const pad = () => lead + ' '.repeat(hang);
+  const push = () => { lines.push(cur); cur = pad(); curHas = false; };
+  for (let word of words) {
+    while (len(cur) + (curHas ? 1 : 0) + len(word) > w) {
+      if (curHas) { push(); continue; }
+      const room = Math.max(1, w - len(cur));
+      const g = [...word];
+      if (g.length <= room) break;
+      cur += g.slice(0, room).join('');
+      word = g.slice(room).join('');
+      push();
+    }
+    cur += (curHas ? ' ' : '') + word;
+    curHas = true;
+  }
+  if (curHas) lines.push(cur);
+  return lines;
+}
+
 /** Clip a row of segments to n chars total; later segments shrink first, the last one gets the ellipsis. */
 export function fitRow(row, n) {
   const out = [];

package/lib/quoxon/objects/peek.js

@@ -0,0 +1,17 @@
+/**
+ * PEEK card: the hit of `/peek <id>` as an inline object (the box layout keeps the label column; a note would
+ * re-flow it). Fields come from core/peek.js ROWS, the same list `quox peek` prints. d: a peekId result.
+ */
+import { seg, fit, boxWidth } from './model.js';
+import { KIND_LABEL, ROWS, MORE } from '../../core/peek.js';
+
+export function peekCard(d, cols) {
+  const w = boxWidth(cols, 84), inner = w - 4;
+  const { kind, data } = d.hit || {};
+  const rows = [];
+  const L = (label, value, role = 'value') => [seg(label.padEnd(10), 'muted'), seg(fit(value, inner - 10), role)];
+  for (const [k, v] of (ROWS[kind] ? ROWS[kind](data || {}) : [])) if (v) rows.push(L(k, v));
+  if (d.also?.length) rows.push(L('also', `an id of the same value: ${d.also.map(k => KIND_LABEL[k]).join(', ')}`, 'muted'));
+  if (MORE[kind]) rows.push(L('more', MORE[kind](d.id), 'muted'));
+  return { box: { width: w, title: `◇ ${KIND_LABEL[kind] || 'id'} ${d.id}`, titleRole: 'sky', right: 'read only', rightRole: 'muted', border: 'sky' }, rows };
+}