atris 3.74.8 → 3.74.9

package/commands/gm.js

@@ -797,19 +797,20 @@ function tail(text, used, width) {
   return clip(text, Math.max(10, width - used));
 }
 
-// Last guard on width: a long line breaks after a comma onto an indented
-// line; anything still too long ends in "...".
+// Last guard on width, in terminal columns: a long line breaks after a
+// comma onto an indented line; anything still too long ends in "...".
 function fitLines(lines, width) {
+  const { displayWidth, sliceColumns } = require('../lib/text-table');
   const out = [];
   for (const line of lines) {
     let rest = line;
-    while (rest.length > width) {
-      const cut = rest.lastIndexOf(', ', width - 1);
+    while (displayWidth(rest) > width) {
+      const cut = rest.lastIndexOf(', ', sliceColumns(rest, width).length - 1);
       if (cut <= 0) break;
       out.push(rest.slice(0, cut + 1));
       rest = `  ${rest.slice(cut + 2)}`;
     }
-    out.push(rest.length > width ? `${rest.slice(0, width - 3)}...` : rest);
+    out.push(displayWidth(rest) > width ? `${sliceColumns(rest, width - 3)}...` : rest);
   }
   return out;
 }
@@ -830,13 +831,30 @@ function boardWorkspaceRoot(args = []) {
   return taskDb.workspaceRoot(path.resolve(workspaceArg));
 }
 
+// The team page's cells (role, ovr, engine) for each roster member, read
+// only when the board draws its box in a terminal; null otherwise.
+function boardCells(board, workspaceRoot, ratings) {
+  if (!process.stdout.isTTY || !workspaceRoot) return null;
+  return require('../lib/gm-bet').teamCells(workspaceRoot, board.roster.map(r => r.name), { ratings });
+}
+
 function loadBoard(workspaceRoot, options = {}) {
+  return loadSeasonBoard(workspaceRoot, options).board;
+}
+
+// The board and every member's rating (gm-season memberRatings, the same
+// numbers the orb's team page reads) from one read of the season.
+function loadSeasonBoard(workspaceRoot, options = {}) {
   const season = require('../lib/gm-season');
-  return season.seasonBoard(season.loadSeason(workspaceRoot, { lastSeen: options.lastSeen }), options);
+  const played = season.loadSeason(workspaceRoot, { lastSeen: options.lastSeen });
+  return { board: season.seasonBoard(played, options), ratings: season.memberRatings(played.outcomes || []) };
 }
 
 // One screen, about 40 rows at most. Pure: board in, lines out.
-function renderBoardLines(board, { interactive = false, width = termWidth() } = {}) {
+// In a terminal, given the team page's cells, the roster is the orb's team
+// table as a divided box (member, role, ovr, engine, status); piped, or when
+// the box cannot fit the width, it keeps the plain columns.
+function renderBoardLines(board, { interactive = false, width = termWidth(), bordered = Boolean(process.stdout.isTTY), cells = null } = {}) {
   const { clockLabel } = require('../lib/gm-season');
   const lines = [];
   const nameW = nameWidth([
@@ -856,7 +874,12 @@ function renderBoardLines(board, { interactive = false, width = termWidth() } =
   lines.push('');
 
   lines.push('roster, last 30 days');
-  if (board.roster.length) {
+  const boxed = bordered && cells && board.roster.length
+    ? require('../lib/gm-bet').teamBox(board.roster.map(r => ({ member: r.name, status: r.status })), cells, { width: width - 2 })
+    : null;
+  if (boxed) {
+    lines.push(...boxed.split('\n').map(line => `  ${line}`));
+  } else if (board.roster.length) {
     lines.push(`  ${pad('name', nameW)}${pad('ovr', 8)}${pad('form', 7)}${pad('record', 18)}status`);
     for (const row of board.roster) {
       const record = `landed ${row.landed} of ${row.jobs}`;
@@ -913,9 +936,10 @@ function renderBoardLines(board, { interactive = false, width = termWidth() } =
   }
   lines.push('');
 
-  lines.push('key: ovr 60 to 99 = share of finished jobs landed, rookie under 3 finished,');
+  lines.push(`key: ovr 60 to 99 = share of finished jobs landed, ${boxed ? 'new' : 'rookie'} under 3 finished,`);
   lines.push('     stricter than the website rating on purpose (drops and abandons count)');
-  lines.push('     form: last 5, newest right: k landed, d dropped, x sent back, a abandoned');
+  if (boxed) lines.push('     ·· = nothing to show yet: no finished job, no role, or no pinned model');
+  else lines.push('     form: last 5, newest right: k landed, d dropped, x sent back, a abandoned');
   lines.push('     hours: claim to result. on a job: moved in the last 6h. review: pending');
   if (interactive) for (const line of PLAY_KEYS) lines.push(line);
   else lines.push('     run atris gm in a terminal to play');
@@ -990,9 +1014,10 @@ function printLeague() {
 }
 
 function printBoard(args = []) {
-  const board = loadBoard(boardWorkspaceRoot(args));
+  const root = boardWorkspaceRoot(args);
+  const { board, ratings } = loadSeasonBoard(root);
   if (board.error) return failRead(board.error);
-  console.log(renderBoardLines(board).join('\n'));
+  console.log(renderBoardLines(board, { cells: boardCells(board, root, ratings) }).join('\n'));
   return undefined;
 }
 
@@ -1107,11 +1132,11 @@ async function gmPlay(args = []) {
         leagueRowsSeen = [...board.rows, ...(board.hidden_clubs || [])];
         write(renderLeagueLines(board, { interactive: true }).join('\n'));
       } else {
-        const board = loadBoard(workspaceRoot, { seen, lastSeen });
+        const { board, ratings } = loadSeasonBoard(workspaceRoot, { seen, lastSeen });
         lastBoard = board;
         seen = new Set(board.last_plays.map(play => play.id));
         stuck = board.stuck || [];
-        write(renderBoardLines(board, { interactive: true }).join('\n'));
+        write(renderBoardLines(board, { interactive: true, cells: boardCells(board, workspaceRoot, ratings) }).join('\n'));
         season.writeLastSeen(workspaceRoot, board.now);
       }
     } catch (err) {
@@ -1986,9 +2011,11 @@ async function gmCommand(...args) {
 }
 
 module.exports = {
+  boardCells,
   displayCommand,
   ensureStarterMission,
   gmCommand,
+  loadSeasonBoard,
   pickClub,
   playAction,
   renderBoardLines,

package/commands/member.js

@@ -11664,6 +11664,44 @@ async function memberStandupWalk(room, args = []) {
   return payload;
 }
 
+// The team page's cells (role, ovr, engine) per standup member, read only
+// when the standup can draw its table (a terminal); --json never carries
+// them. ovr comes from gm-season memberRatings, as on the orb's team page.
+function standupTableData(standup, cwd = process.cwd()) {
+  if (!process.stdout.isTTY) return { bordered: false };
+  const season = require('../lib/gm-season');
+  const root = require('../lib/task-db').workspaceRoot(path.resolve(cwd));
+  let ratings = new Map();
+  try {
+    const played = season.loadSeason(root, { lastSeen: null });
+    if (played && !played.error) ratings = season.memberRatings(played.outcomes || []);
+  } catch { ratings = new Map(); }
+  const cells = require('../lib/gm-bet').teamCells(root, standup.map((s) => s.member), { ratings });
+  return { bordered: true, cells };
+}
+
+// The standup: in a terminal the orb's team table as a divided box
+// (member, role, ovr, engine, status) with each member's found and push
+// lines under it; piped, or when the box cannot fit, the boxes it always had.
+function memberStandupLines(standup, { bordered = false, width = process.stdout.columns, cells = null } = {}) {
+  if (bordered && cells && standup.length) {
+    const table = require('../lib/gm-bet').teamBox(standup.map((s) => ({ member: s.member, status: s.status })), cells, { width: Number(width) - 2 });
+    if (table) {
+      return [
+        ...table.split('\n').map((line) => `  ${line}`),
+        ...standup.flatMap((s) => [`  ${s.member}`, `    found: ${s.latest_update}`, `    push:  ${s.next_push}`]),
+      ];
+    }
+  }
+  return standup.flatMap((s, idx) => [
+    `+-----------------------------------------------------------------------+`,
+    `| ${idx + 1}. ${s.member.toUpperCase()} (${s.role}) · ${s.status} · engine:${s.engine}`,
+    `|    Found:   ${s.latest_update}`,
+    `|    Push:    ${s.next_push}`,
+    `+-----------------------------------------------------------------------+`,
+  ]);
+}
+
 async function memberRoom(...args) {
   if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('Usage: atris member [day|standup|room] [--walk] [--limit N] [--decisions "y|idea|n"] [--json]');
@@ -11680,13 +11718,7 @@ async function memberRoom(...args) {
     ? `Your team runs on ${teamEngines.length > 1 ? `${teamEngines.slice(0, -1).join(', ')} and ${teamEngines[teamEngines.length - 1]}` : teamEngines[0]}.`
     : 'Your team picks an engine for each job.';
 
-  const standupRows = room.standup.flatMap((s, idx) => [
-    `+-----------------------------------------------------------------------+`,
-    `| ${idx + 1}. ${s.member.toUpperCase()} (${s.role}) · ${s.status} · engine:${s.engine}`,
-    `|    Found:   ${s.latest_update}`,
-    `|    Push:    ${s.next_push}`,
-    `+-----------------------------------------------------------------------+`,
-  ]);
+  const standupRows = memberStandupLines(room.standup, standupTableData(room.standup));
 
   const handoffRows = room.handoffs.length
     ? room.handoffs.map((h) => `  - ${h.from} -> ${h.to}: ${h.summary} (run: ${h.next_command})`)
@@ -12019,6 +12051,8 @@ async function memberCommand(subcommand, ...args) {
 
 module.exports = {
   logDateForScan,
+  memberStandupLines,
+  standupTableData,
   memberRunDefaultWallSeconds,
   memberRunWantsReferee,
   proposalPromptForGoal,

package/lib/gm-bet.js

@@ -849,6 +849,65 @@ function statusSentence(row) {
   return `${row.status}: ${on}, ${row.time}`;
 }
 
+// The ovr cell from one member's entry in gm-season memberRatings: the
+// rating, "new" with 1 or 2 finished, two dots with none finished.
+function ovrCell(rated) {
+  if (!rated || !rated.finished) return NO_RATING;
+  return rated.ovr == null ? 'new' : String(rated.ovr);
+}
+
+// The engine pick the runner makes for a member, with the roster read once.
+function teamEngineResolver(workspaceRoot) {
+  const reg = require('./engine-registry');
+  const { resolveEngineForMember } = require('./member-engine');
+  let rosterState = null;
+  try { rosterState = reg.readRosterState(workspaceRoot); } catch { rosterState = null; }
+  return name => resolveEngineForMember(name, workspaceRoot, { quiet: true, ...(rosterState ? { rosterState } : {}) });
+}
+
+// role, ovr, engine, and parked for each name: the team page's cells, and
+// the same cells the board and the standup draw in a terminal, so every
+// team view says the same thing. ratings is gm-season memberRatings over one
+// loaded season; resolve gives a member's engine pick. A name with no card
+// and no roster line is not on the team, so no engine shows for it.
+function teamCells(workspaceRoot, names = [], { ratings = new Map(), resolve = null } = {}) {
+  const { memberTypeOf } = require('./member-type');
+  const pick = resolve || teamEngineResolver(workspaceRoot);
+  const out = new Map();
+  for (const name of names) {
+    const key = String(name || '');
+    if (!key || /[\\/]/.test(key) || key === '.' || key === '..') {
+      out.set(key, { role: NO_RATING, ovr: ovrCell(ratings.get(key)), engine: NO_RATING, parked: false });
+      continue;
+    }
+    const card = memberCardFacts(workspaceRoot, key);
+    const kind = memberTypeOf({ type: card.type });
+    let engine = kind.type === 'human' ? 'person' : NO_RATING;
+    if (kind.runnable) {
+      let picked = null;
+      try { picked = pick(key); } catch { picked = null; }
+      engine = picked && picked.found === false ? NO_RATING : engineWords(picked);
+    }
+    out.set(key, { role: memberRoleWords(key, card), ovr: ovrCell(ratings.get(key)), engine, parked: card.parked });
+  }
+  return out;
+}
+
+// The team table as a divided box for a terminal, in the team page's
+// columns: one line per { member, status } with that member's cells from
+// teamCells. A long role or status wraps to fit the width (the exact model
+// never splits); null when even that does not fit.
+function teamBox(rows, cells, { width } = {}) {
+  const { renderBorderedTable } = require('./text-table');
+  const wraps = new Set(['role', 'status']);
+  const columns = require('./gm-card').TEAM_COLUMNS.map(header => ({ header, wrap: wraps.has(header) }));
+  const blank = { role: NO_RATING, ovr: NO_RATING, engine: NO_RATING };
+  return renderBorderedTable(columns, (rows || []).map((row) => {
+    const c = (cells && cells.get(row.member)) || blank;
+    return [row.member, c.role, c.ovr, c.engine, row.status];
+  }), { width });
+}
+
 // A verify command that always passes proves nothing. Binary checks only:
 // every piece of it is one of these, or it swallows failure with || true.
 const TRIVIAL_VERIFY = [
@@ -4252,33 +4311,7 @@ function createBetDesk(deps) {
       const loaded = (deps.loadSeason || (root => season.loadSeason(root, { now: now(), lastSeen: null })))(deps.workspaceRoot);
       if (loaded && !loaded.error) ratings = season.memberRatings(loaded.outcomes || []);
     } catch { ratings = new Map(); }
-    let resolve = deps.resolveEngine;
-    if (!resolve) {
-      const reg = require('./engine-registry');
-      const { resolveEngineForMember } = require('./member-engine');
-      let rosterState = null;
-      try { rosterState = reg.readRosterState(deps.workspaceRoot); } catch { rosterState = null; }
-      resolve = name => resolveEngineForMember(name, deps.workspaceRoot, { quiet: true, ...(rosterState ? { rosterState } : {}) });
-    }
-    const facts = new Map();
-    const { memberTypeOf } = require('./member-type');
-    for (const m of team || []) {
-      const card = memberCardFacts(deps.workspaceRoot, m.name);
-      const kind = memberTypeOf({ type: card.type });
-      let engine = kind.type === 'human' ? 'person' : NO_RATING;
-      if (kind.runnable) {
-        let picked = null;
-        try { picked = resolve(m.name); } catch { picked = null; }
-        engine = engineWords(picked);
-      }
-      const rated = ratings.get(m.name);
-      facts.set(m.name, {
-        role: memberRoleWords(m.name, card),
-        ovr: !rated || !rated.finished ? NO_RATING : rated.ovr == null ? 'new' : String(rated.ovr),
-        engine,
-        parked: card.parked,
-      });
-    }
+    const facts = teamCells(deps.workspaceRoot, (team || []).map(m => m.name), { ratings, resolve: deps.resolveEngine || null });
     rosterCache = { at: now(), facts };
     return facts;
   }
@@ -4857,4 +4890,6 @@ module.exports = {
   writerCommand,
   WRITER_ANGLES,
   validateBet,
+  teamBox,
+  teamCells,
 };

package/lib/gm-phone-page.js

@@ -357,8 +357,10 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     // when a spiral starts, each dot keeps the speed it had and lets it fade
     // at CARRY a frame, so the dots turn inward without a stop
     var CARRY = 0.82;
-    // what the dots did on the last frame, kept on the canvas so the motion can be measured
-    var stats = { frame: 0, mode: 'idle', step: 0, mean: 0 };
+    // what the dots did on the last frame, kept on the canvas so the motion can be
+    // measured, and ms: how much of the dots' own clock that frame was, which is
+    // at most 50ms however long the frame took
+    var stats = { frame: 0, mode: 'idle', step: 0, mean: 0, ms: 0 };
     canvas.__orb = stats;
     // Two speeds, chosen by truth. A bet already waiting in the queue plays
     // the same curves at FAST of their length (tap to card in about two seconds, unhurried).
@@ -523,7 +525,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
         ctx.arc(d.sx, d.sy, d.r * (front ? 0.6 + l * 0.7 : 0.6) * shrink, 0, Math.PI * 2);
         ctx.fill();
       }
-      stats.frame += 1; stats.mode = mode; stats.step = most; stats.mean = sum / Math.min(64, dots.length || 1);
+      stats.frame += 1; stats.mode = mode; stats.step = most; stats.mean = sum / Math.min(64, dots.length || 1); stats.ms = dt * 1000;
       if (mode === 'pull') {
         // where the dots land: one bright point that swells until the lava is born
         var arrived = Math.min(1, Math.max(0, (age - 0.3) / 0.7));
@@ -556,7 +558,9 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     function start() { if (!raf) { lastT = 0; raf = requestAnimationFrame(frame); } }
     function stop() { if (raf) cancelAnimationFrame(raf); raf = 0; }
 
-    function place(s, x, y) { lava.style.transform = 'translate(' + (x - base / 2) + 'px, ' + (y - base / 2) + 'px) scale(' + s + ')'; }
+    // at: the frame time this place is for, when it is a step of a motion, kept on
+    // the lava so the motion can be measured on the clock it runs on
+    function place(s, x, y, at) { lava.style.transform = 'translate(' + (x - base / 2) + 'px, ' + (y - base / 2) + 'px) scale(' + s + ')'; lava.__at = at; }
     function restPoint() {
       var top = parseFloat(getComputedStyle(document.documentElement).getPropertyValue('--safe-top')) || 0;
       return { x: document.documentElement.clientWidth / 2, y: window.scrollY + Math.max(16, top) + 8 + REST / 2 };
@@ -574,6 +578,9 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
       var contained = pace < 1;
       var growMs = quick ? ACT_GROW_MS : contained ? FAST_GROW_MS : (GROW_MS * pace);
       var settleMs = quick ? ACT_SETTLE_MS : contained ? FAST_SETTLE_MS : (SETTLE_MS * pace);
+      // after an act the card comes up at the bloom's peak; any other card once the lava has settled
+      planned('bloom', growMs);
+      if (!quick) planned('settle', settleMs);
       // the point the dots drew, where the sphere is on screen (smaller and higher on the calm line)
       var vx = rect.left + rect.width / 2, vy = rect.top + rect.height / 2;
       var bloom = quick ? ACT_BLOOM : BLOOM;
@@ -598,7 +605,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
       var t0 = performance.now();
       var step = function (now) {
         var t = Math.min(1, (now - t0) / growMs);
-        place(sMin + (sMax - sMin) * ease(t), origin.x, origin.y);
+        place(sMin + (sMax - sMin) * ease(t), origin.x, origin.y, now);
         lava.style.opacity = String(smooth(0.02, 0.22, t));
         core.style.opacity = String(1 - smooth(0.05, 0.4, t));
         dim.style.opacity = contained ? '0' : String(smooth(0.88, 1, t));
@@ -612,7 +619,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
         var s0 = performance.now();
         var settle = function (n2) {
           var u = ease(Math.min(1, (n2 - s0) / settleMs));
-          place(sMax + (rest - sMax) * u, origin.x + (p.x - origin.x) * u, origin.y + (p.y - origin.y) * u);
+          place(sMax + (rest - sMax) * u, origin.x + (p.x - origin.x) * u, origin.y + (p.y - origin.y) * u, n2);
           dim.style.opacity = contained ? '0' : String(1 - smooth(0.35, 0.85, u));
           if (u < 1) { requestAnimationFrame(settle); return; }
           settled();
@@ -636,7 +643,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
         var u = Math.min(1, (now - t0) / total);
         var s = u < k ? sMin + (sMax - sMin) * (0.5 - 0.5 * Math.cos(Math.PI * u / k)) : sMax + (rest - sMax) * ease((u - k) / (1 - k));
         var m = ease(u);
-        place(s, origin.x + (p.x - origin.x) * m, origin.y + (p.y - origin.y) * m);
+        place(s, origin.x + (p.x - origin.x) * m, origin.y + (p.y - origin.y) * m, now);
         lava.style.opacity = String(smooth(0, 0.1, u));
         core.style.opacity = String(1 - smooth(0.04, 0.5, u));
         dim.style.opacity = '0';
@@ -700,6 +707,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
         mode = fast ? 'swarm' : 'idle';
         bridgeAt = reduced ? 0 : performance.now();
         start();
+        if (!reduced) planned('beat', beatMs);
         setTimeout(cb, reduced ? 0 : beatMs);
       };
       if (reduced || lava.style.visibility !== 'visible') { reform(); return; }
@@ -709,12 +717,13 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
       lava.style.position = 'fixed';
       place(from.s, from.x, from.y);
       var sEnd = 30 / base;
+      planned('glide', glideMs);
       var t0 = performance.now();
       var step = function (now) {
         var k = Math.min(1, (now - t0) / glideMs);
         var t = fast ? 0.5 - 0.5 * Math.cos(Math.PI * k) : ease(k);
         if (now - t0 >= leaveMs) takeOff();
-        place(from.s + (sEnd - from.s) * t, from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t);
+        place(from.s + (sEnd - from.s) * t, from.x + (to.x - from.x) * t, from.y + (to.y - from.y) * t, now);
         core.style.opacity = String(smooth(0.3, 0.9, k));
         lava.style.opacity = String(1 - smooth(0.7, 1, k));
         if (k < 1) { requestAnimationFrame(step); return; }
@@ -767,6 +776,8 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
         pace = act ? ACT_PACE : fast ? FAST : 1;
         // after an act the dots spiral in from where the re-formed sphere is
         if (mode !== 'pull') startPull(fast || Boolean(act));
+        // the lava is born at 1.05 on the spiral's own clock, which runs at pace
+        planned('spiral', Math.max(0, 1.05 - age) * pace * 1000);
         timed = true;
         start();
       },
@@ -817,7 +828,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
   // card, and nothing from the card before survives a draw. Every tap posts
   // the card's id and the option's id, or the words typed in its box, to
   // /card; the Mac refuses anything else, and its answer is the next card.
-  var bet = { shown: null, watching: null, tapAt: 0, noting: false, clock: null };
+  var bet = { shown: null, watching: null, tapAt: 0, plan: [], waited: 0, noting: false, clock: null };
   // while an act or a turn is under way the card takes no taps; the page
   // marks it on the body too, so anyone reading the page can tell
   var busyNow = false;
@@ -991,9 +1002,9 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     var input = spot.querySelector('input');
     if (input) { input.readOnly = true; input.blur(); }
     bet.busy = true;
-    bet.tapAt = performance.now();
-    document.body.removeAttribute('data-reveal-ms');
-    return bet.tapAt;
+    var at = tapped();
+    planned('hold', HOLD_MS);
+    return at;
   }
 
   function afterHold(heldAt) {
@@ -1088,12 +1099,16 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
   function flow(answer, from, typed, option) {
     var landed = null;
     var sphere = false;
-    var lineAt = 0;
+    var lineAt = 0, waitFrom = 0;
     var land = function () {
+      // the sphere is ready before the answer is in: it waits from now
+      if (sphere && !landed) waitFrom = performance.now();
       if (!landed || !sphere) return;
+      if (waitFrom) bet.waited += performance.now() - waitFrom;
       var r = landed;
       landed = null;
       var wait = r.ack && lineAt ? Math.max(0, AFTER_MS - (performance.now() - lineAt)) : 0;
+      if (wait) planned('line', wait);
       setTimeout(function () {
         // nothing more to show: the sphere stays, with its line, and its dots settle into the idle drift
         if (r.ok && (r.home || !r.card)) { bet.busy = false; bet.shown = null; orb.calm(); line.set(r.home ? 'not now. tap when you want another' : 'tap to think', false); return; }
@@ -1133,6 +1148,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     // reduced motion: no travel; the card and the small orb fade, then the sphere is there
     if (reduced) {
       document.getElementById('lava').style.opacity = '0';
+      planned('leave', 200);
       setTimeout(function () { swap(); stageFade(); orb.melt(then, to, function () {}, fast); }, 200);
       return;
     }
@@ -1185,12 +1201,35 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
   }
 
   // ---- showing a card ---------------------------------------------------------------------
-  // the time from the tap to the card fully on screen, kept on the page so
-  // the speed can be measured
+  // The time from the tap to the card fully on screen, kept on the page so
+  // the speed can be measured. data-reveal-ms is the clock. data-reveal-plan
+  // is each step of the motion in order with the length it is set to take,
+  // and data-reveal-waited-ms is how long the sphere waited on the Mac's
+  // answer, so late frames on a busy machine are told apart from the motion.
+  var REVEAL = ['data-reveal-ms', 'data-reveal-plan', 'data-reveal-waited-ms'];
+  function tapped() {
+    bet.tapAt = performance.now();
+    bet.plan = [];
+    bet.waited = 0;
+    REVEAL.forEach(function (a) { document.body.removeAttribute(a); });
+    return bet.tapAt;
+  }
+  function planned(name, ms) { if (bet.tapAt) bet.plan.push(name + ' ' + Math.round(ms)); }
   function measured() {
-    if (bet.tapAt) document.body.setAttribute('data-reveal-ms', String(Math.round(performance.now() - bet.tapAt)));
+    if (bet.tapAt) {
+      document.body.setAttribute('data-reveal-plan', bet.plan.join(', '));
+      document.body.setAttribute('data-reveal-waited-ms', String(Math.round(bet.waited)));
+      document.body.setAttribute('data-reveal-ms', String(Math.round(performance.now() - bet.tapAt)));
+    }
     bet.tapAt = 0;
   }
+  // how long a card's own fade up is set to take, read from its style
+  function fadeMs(n) {
+    var s = getComputedStyle(n);
+    var i = Math.max(0, s.transitionProperty.split(', ').indexOf('opacity'));
+    var at = function (list) { var v = list.split(', '); return (parseFloat(v[i % v.length]) || 0) * 1000; };
+    return at(s.transitionDelay) + at(s.transitionDuration);
+  }
 
   // fast: the quick fade from the big orb; act: the short one after an act
   function showCard(card, animate, fast, act) {
@@ -1213,7 +1252,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     var done = function (e) { if (e.propertyName === 'opacity') { b.removeEventListener('transitionend', done); measured(); } };
     b.addEventListener('transitionend', done);
     void b.offsetWidth;
-    requestAnimationFrame(function () { b.classList.add('up'); });
+    requestAnimationFrame(function () { b.classList.add('up'); planned('fade', fadeMs(b)); });
   }
 
   // ---- the calm line: the dots keep moving while the next idea is written -----------------
@@ -1487,12 +1526,14 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     b.classList.remove('turn-in');
     b.style.height = to + 'px';
     ghost.classList.add('gone');
+    var turnMs = 80 + TURN_IN_MS + 20;
+    planned('turn', turnMs);
     setTimeout(function () {
       ghost.remove();
       b.classList.remove('turning');
       b.style.height = '';
       after();
-    }, 80 + TURN_IN_MS + 20);
+    }, turnMs);
   }
 
   // While the calm line shows, look every WAIT_LOOK_MS: its live words are
@@ -1536,8 +1577,7 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     if (waiting()) { goHome(); return; }
     buzz();
     bet.busy = true;
-    bet.tapAt = performance.now();
-    document.body.removeAttribute('data-reveal-ms');
+    tapped();
     var failed = function () {
       bet.busy = false;
       orb.relax();
@@ -1548,6 +1588,8 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
       line.set('', false);
       // nothing ready yet: the calm line, with the sphere where it is and its dots moving
       if (isWait(r.card)) { enterWait(r.card); return; }
+      // the big orb moves once the answer is in
+      bet.waited = performance.now() - bet.tapAt;
       orb.play(function (phase) { if (phase === 'settled') { bet.busy = false; showCard(r.card, true, true); } }, true);
     }, failed);
   }
@@ -1598,11 +1640,12 @@ body.waiting .bet { position: absolute; left: 24px; right: 24px; width: auto; to
     if (bet.busy) return;
     buzz();
     bet.busy = true;
-    bet.tapAt = performance.now();
+    tapped();
     var answer = api('/act', { open: which, card_id: bet.shown ? bet.shown.id : null }).catch(offline);
     if (!document.body.classList.contains('has-card')) {
       answer.then(function (r) {
         if (!r.ok || !r.card) { bet.busy = false; line.set((r && r.message) || 'that did not go through. tap to try again', true); return; }
+        bet.waited = performance.now() - bet.tapAt;
         spiralTo(r.card, null);
       });
       return;

package/lib/text-table.js

@@ -6,6 +6,16 @@
 // than the terminal, columns marked `clip` or `wrap` shrink (rightmost
 // first): a clip column ends in "…", a wrap column carries on underneath.
 // Every other column keeps its full width.
+//
+// renderBorderedTable draws the same rows as a divided box, the look of the
+// orb's team table. A box wider than the terminal narrows its `wrap`
+// columns, the widest first, and their words carry on underneath; when it
+// still does not fit it returns null and the caller prints its plain view.
+//
+// Every width here is terminal columns, not string length (displayWidth):
+// a wide or fullwidth character takes 2, a joiner, variation selector, or
+// combining mark takes 0, and a joined emoji is one 2-column cluster. Cuts
+// and wraps fall between clusters, never inside one.
 
 const GAP = '  ';
 const ELLIPSIS = '…';
@@ -16,25 +26,110 @@ function terminalWidth(width) {
   return Number.isFinite(value) && value >= 20 ? value : FALLBACK_WIDTH;
 }
 
+// East Asian wide and fullwidth code points, as [first, last] ranges.
+const WIDE = [
+  [0x1100, 0x115f], [0x231a, 0x231b], [0x2329, 0x232a], [0x2e80, 0x303e], [0x3041, 0x33ff],
+  [0x3400, 0x4dbf], [0x4e00, 0x9fff], [0xa000, 0xa4cf], [0xa960, 0xa97f], [0xac00, 0xd7a3],
+  [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60], [0xffe0, 0xffe6],
+  [0x16fe0, 0x16fe4], [0x17000, 0x18cff], [0x1aff0, 0x1b2ff], [0x1f200, 0x1f2ff],
+  [0x20000, 0x2fffd], [0x30000, 0x3fffd],
+];
+// takes no column: combining marks, joiners and other format characters,
+// variation selectors, and the Hangul vowel and final jamo that join a syllable
+const ZERO = /^[\p{Mn}\p{Me}\p{Cf}\u1160-\u11ff\ud7b0-\ud7ff]$/u;
+// drawn as a 2-column emoji: emoji presentation, or an emoji asked for one
+// with the U+FE0F selector or a keycap
+const EMOJI = /\p{Emoji_Presentation}|\p{Emoji}\ufe0f|\u20e3/u;
+const SEGMENTER = typeof Intl === 'object' && typeof Intl.Segmenter === 'function'
+  ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+  : null;
+
+function isWide(code) {
+  for (const [first, last] of WIDE) {
+    if (code < first) return false;
+    if (code <= last) return true;
+  }
+  return false;
+}
+
+// The text as grapheme clusters: what a reader sees as one character.
+// Without Intl.Segmenter a zero-width code point joins the cluster before it.
+function graphemes(text) {
+  const value = String(text);
+  if (SEGMENTER) return Array.from(SEGMENTER.segment(value), (part) => part.segment);
+  const out = [];
+  let joined = false;
+  for (const ch of value) {
+    if (out.length && (joined || ZERO.test(ch))) out[out.length - 1] += ch;
+    else out.push(ch);
+    joined = ch === '\u200d';
+  }
+  return out;
+}
+
+// Terminal columns for one cluster: 0, 1, or 2.
+function clusterWidth(cluster) {
+  const code = cluster.codePointAt(0);
+  if (cluster.length === 1 && code >= 0x20 && code < 0x7f) return 1;
+  if (code < 0x20 || (code >= 0x7f && code < 0xa0)) return 0;
+  if (EMOJI.test(cluster)) return 2;
+  for (const ch of cluster) {
+    if (!ZERO.test(ch)) return isWide(ch.codePointAt(0)) ? 2 : 1;
+  }
+  return 0;
+}
+
+// Terminal columns the text takes.
+function displayWidth(text) {
+  const value = String(text);
+  // printable ascii is one column a character
+  if (/^[\x20-\x7e]*$/.test(value)) return value.length;
+  let total = 0;
+  for (const cluster of graphemes(value)) total += clusterWidth(cluster);
+  return total;
+}
+
+// The longest start of the text that fits in that many columns, whole
+// clusters only.
+function sliceColumns(text, columns) {
+  let out = '';
+  let used = 0;
+  for (const cluster of graphemes(text)) {
+    const w = clusterWidth(cluster);
+    if (used + w > columns) break;
+    out += cluster;
+    used += w;
+  }
+  return out;
+}
+
+// Pads with spaces to that many columns.
+function padColumns(text, columns) {
+  const value = String(text);
+  return value + ' '.repeat(Math.max(0, columns - displayWidth(value)));
+}
+
 function clipText(text, width) {
   const value = String(text);
-  if (value.length <= width) return value;
+  if (displayWidth(value) <= width) return value;
   if (width <= 1) return ELLIPSIS.slice(0, Math.max(0, width));
-  return `${value.slice(0, width - 1).trimEnd()}${ELLIPSIS}`;
+  return `${sliceColumns(value, width - 1).trimEnd()}${ELLIPSIS}`;
 }
 
-// Word-wrap one line to a width; a word longer than the width is split.
+// Word-wrap one line to a width in columns; a word wider than the width is
+// split between clusters (a lone cluster wider than the width stands alone).
 function wrapText(text, width) {
   const out = [];
   let line = '';
   for (let word of String(text).split(' ')) {
-    while (word.length > width) {
+    while (displayWidth(word) > width) {
       if (line) { out.push(line); line = ''; }
-      out.push(word.slice(0, width));
-      word = word.slice(width);
+      const head = sliceColumns(word, width) || graphemes(word)[0];
+      out.push(head);
+      word = word.slice(head.length);
     }
     const next = line ? `${line} ${word}` : word;
-    if (next.length > width && line) { out.push(line); line = word; } else line = next;
+    if (displayWidth(next) > width && line) { out.push(line); line = word; } else line = next;
   }
   out.push(line);
   return out;
@@ -54,19 +149,19 @@ function renderTable(columns, rows, { width } = {}) {
   const max = terminalWidth(width);
   const cells = rows.map((row) => columns.map((_, index) => cellLines(row[index])));
   const widths = columns.map((column, index) => Math.max(
-    String(column.header).length,
-    ...cells.map((row) => Math.max(...row[index].map((line) => line.length))),
+    displayWidth(column.header),
+    ...cells.map((row) => Math.max(...row[index].map(displayWidth))),
   ));
   let over = widths.reduce((sum, value) => sum + value, 0) + GAP.length * (columns.length - 1) - max;
   for (let index = columns.length - 1; index >= 0 && over > 0; index -= 1) {
     if (!columns[index].clip && !columns[index].wrap) continue;
-    const floor = Math.max(String(columns[index].header).length, columns[index].min || 8);
+    const floor = Math.max(displayWidth(columns[index].header), columns[index].min || 8);
     const cut = Math.min(over, Math.max(0, widths[index] - floor));
     widths[index] -= cut;
     over -= cut;
   }
   const line = (parts) => parts
-    .map((text, index) => clipText(text, widths[index]).padEnd(index === parts.length - 1 ? 0 : widths[index]))
+    .map((text, index) => padColumns(clipText(text, widths[index]), index === parts.length - 1 ? 0 : widths[index]))
     .join(GAP)
     .trimEnd();
   const out = [line(columns.map((column) => column.header))];
@@ -78,4 +173,35 @@ function renderTable(columns, rows, { width } = {}) {
   return out.join('\n');
 }
 
-module.exports = { FALLBACK_WIDTH, clipText, renderTable, terminalWidth };
+// columns: [{ header, wrap?, min? }]; rows: arrays of cells. A divided box,
+// or null when it cannot fit the terminal.
+function renderBorderedTable(columns, rows, { width } = {}) {
+  const cells = rows.map((row) => columns.map((_, index) => cellLines(row[index])));
+  const widths = columns.map((column, index) => Math.max(
+    displayWidth(column.header),
+    ...cells.map((row) => Math.max(...row[index].map(displayWidth))),
+  ));
+  const floor = (index) => Math.max(displayWidth(columns[index].header), columns[index].min || 8);
+  let over = widths.reduce((sum, value) => sum + value + 3, 1) - terminalWidth(width);
+  while (over > 0) {
+    let widest = -1;
+    columns.forEach((column, index) => {
+      if (column.wrap && widths[index] > floor(index) && (widest < 0 || widths[index] > widths[widest])) widest = index;
+    });
+    if (widest < 0) return null;
+    widths[widest] -= 1;
+    over -= 1;
+  }
+  const rule = (left, mid, right) => `${left}${widths.map((w) => '─'.repeat(w + 2)).join(mid)}${right}`;
+  const line = (parts) => `│ ${parts.map((text, index) => padColumns(text, widths[index])).join(' │ ')} │`;
+  const out = [rule('┌', '┬', '┐'), line(columns.map((column) => column.header)), rule('├', '┼', '┤')];
+  for (const raw of cells) {
+    const row = raw.map((lines, index) => (columns[index].wrap ? lines.flatMap((text) => wrapText(text, widths[index])) : lines));
+    const height = Math.max(...row.map((lines) => lines.length));
+    for (let at = 0; at < height; at += 1) out.push(line(row.map((lines) => lines[at] || '')));
+  }
+  out.push(rule('└', '┴', '┘'));
+  return out.join('\n');
+}
+
+module.exports = { FALLBACK_WIDTH, clipText, displayWidth, renderBorderedTable, renderTable, sliceColumns, terminalWidth, wrapText };

package/lib/zen-apply.js

@@ -547,7 +547,7 @@ function applyZen({ cwd = process.cwd(), fetch = true, freshMinutes, abandonedDa
   if (copies.busy.length) left.push(...sideCopyLines(copies.busy, staleDays, nextSaveIn(copies.busy, staleDays, now.getTime())));
   if (copies.scheduled) left.push(`${plural(copies.scheduled, 'side copy is', 'side copies are')} used by a scheduled job, so ${copies.scheduled === 1 ? 'it stays' : 'they stay'}`);
   if (copies.locked) left.push(`${plural(copies.locked, 'side copy is', 'side copies are')} locked by ${copies.locked === 1 ? 'its owner, so it stays' : 'their owners, so they stay'}`);
-  if (copies.inUse) left.push(`${plural(copies.inUse, 'side copy was', 'side copies were')} used in ${window}`);
+  if (copies.inUse) left.push(`${plural(copies.inUse, 'side copy was', 'side copies were')} used in ${window}, so ${copies.inUse === 1 ? 'it stays' : 'they stay'}`);
 
   const stray = saveStrayEdits(root, teamState, tag, cutoff);
   if (stray.saved) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.8",
+  "version": "3.74.9",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",

package/scripts/det/ytnotes

@@ -428,10 +428,14 @@ run_haiku() {
 # The Antigravity editor ships its own `agy` (a VS Code-style launcher script).
 # It has no -p mode: it hands -p and --model to Electron and prints nothing, so
 # it is not a writer. Only the Antigravity CLI is.
+# Only grep's answer counts, never head's exit. In `head | grep -q` under
+# pipefail, grep quits on the match and a head that touches the pipe once
+# more (uutils head on Ubuntu 26.04 does, to find the end of the file) dies
+# of SIGPIPE, so a busy machine read the launcher as the CLI.
 agy_is_cli() {
   local bin
   bin=$(command -v agy 2>/dev/null) || return 1
-  ! head -c 4096 "$bin" 2>/dev/null | grep -q 'VSCODE_IPC_HOOK_CLI'
+  ! grep -q 'VSCODE_IPC_HOOK_CLI' < <(head -c 4096 "$bin" 2>/dev/null)
 }
 
 # An agy that is not signed in opens a Google login and waits up to 60s, which
@@ -441,7 +445,7 @@ agy_is_cli() {
 agy_signed_in() {
   local out
   out=$(run_with_timeout 10 agy models </dev/null 2>&1) || true
-  ! printf '%s' "$out" | grep -qi 'sign in'
+  ! grep -qi 'sign in' <<< "$out"
 }
 
 run_gemini() {
@@ -524,7 +528,9 @@ run_auto() {
       echo "$tried did not answer; writing the notes with $label instead." >&2
     fi
     rm -f "$WORK/yt_${ID}.kill"
-    if out=$(run_writer "$cmd" "$model" "$effort" 2>>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
+    # A here-string, not printf | grep -q: under pipefail printf can die of
+    # SIGPIPE after grep's match and turn a real answer into "did not answer".
+    if out=$(run_writer "$cmd" "$model" "$effort" 2>>"$WORK/yt_${ID}.engine.err") && grep -q '[[:alnum:]]' <<< "$out"; then
       printf '%s\n' "$out"
       echo "notes by $label" >&2
       return 0