atris 3.68.4 → 3.68.6

package/bin/atris.js

@@ -630,6 +630,7 @@ function showHelpAll() {
   console.log('  rainmaker  - Relationship manager dashboard (atrisos-backend/scripts/rainmaker.py)');
   console.log('  meet       - onboard a stranger in one sitting and print their /book link');
   console.log('  avail      - Booking availability (/book/{username} weekly windows)');
+  console.log('  scoreboard - Today\'s github contributions vs your best day, streak, repo commits (--watch)');
   console.log('  brain      - Compile MAP/TODO/wiki/state into a loadable agent brain');
   console.log('  lesson     - atris lesson add <slug> <pass|fail> "<text>" (mine/sweep/resolve/revert/ledger; --detector validates the falsifier at write time)');
   console.log('  taste      - Record the operator\'s keep, kill, and more creative verdicts');
@@ -2189,6 +2190,10 @@ if (command === 'guide') {
       .then((code) => process.exit(typeof code === 'number' ? code : 0))
       .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
   }
+} else if (command === 'scoreboard') {
+  Promise.resolve(require('../commands/scoreboard').scoreboardCommand(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'meet') {
   Promise.resolve(require('../commands/meet').meetCommand(process.argv.slice(3)))
     .then((code) => process.exit(typeof code === 'number' ? code : 0))

package/commands/member.js

@@ -9937,6 +9937,7 @@ function scrubFeedJargon(text) {
   return String(text || '')
     .replace(/\bmission-\d{4}-\d{2}-\d{2}-[a-z0-9-]+\b/gi, '')
     .replace(/\b[0-9a-f]{7,40}\b/g, '')
+    .replace(/\(\s*(commit\s*)?\)/gi, '')
     .replace(/\s+/g, ' ')
     .trim();
 }
@@ -9966,68 +9967,65 @@ function buildMemberImpactChain({ summary, verified, goalWhy, nextPush, skills =
   };
 }
 
+// Rows that only look like work: placeholder goals, wake and blocked
+// notices, empty "logged update" rows, and raw commands.
+function isFeedFillerText(text) {
+  const t = String(text || '').trim();
+  if (!t) return true;
+  if (/^serve the team as\b/i.test(t)) return true;
+  if (/^member (wake|goal-from-mission|goal created|initialized)\b/i.test(t)) return true;
+  if (/^\[?logged update\]?$/i.test(t)) return true;
+  if (/^(next[_ ]push|verdict):/i.test(t)) return true;
+  if (/^[`'"]?atris\s/i.test(t) || /\batris\s+[a-z-]+\s+[a-z-]+\s+--[a-z]/i.test(t)) return true;
+  return false;
+}
+
+// How a row was checked, in words a reader can follow without the command.
+function plainFeedCheckLabel(state, verifierCommand = '') {
+  if (state === 'failed') return 'check failed, needs another pass';
+  if (state !== 'passed') return 'not checked yet';
+  const cmd = String(verifierCommand || '');
+  if (/\b(npm|pnpm|yarn)\s+(run\s+)?test\b|--test\b|\bpytest\b|\bjest\b|\bvitest\b/i.test(cmd)) return 'checked: tests passed';
+  if (/git\s+diff\s+--check/i.test(cmd)) return 'checked: the change has no whitespace errors';
+  if (/\b(lint|eslint|tsc)\b/i.test(cmd)) return 'checked: lint passed';
+  return 'checked: its check passed';
+}
+
+function feedEntryTimeMs(file, header, fallbackMs) {
+  const day = String(file).match(/^(\d{4})-(\d{2})-(\d{2})\.md$/);
+  const clock = String(header).match(/^(\d{2}):(\d{2})\b/);
+  if (!day) return fallbackMs;
+  const ms = new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3]), clock ? Number(clock[1]) : 23, clock ? Number(clock[2]) : 59).getTime();
+  return Number.isFinite(ms) ? Math.min(ms, fallbackMs || ms) : fallbackMs;
+}
+
+// The feed reads member log entries that say what changed. Mission records
+// only hold the assignment, so they are used to name how the work was checked.
 function collectMemberWorkFeed(root = process.cwd(), options = {}) {
   const teamDir = path.join(root, 'atris', 'team');
   const members = findAllMembers(teamDir).filter(isFleetMember);
-  const roleByMember = new Map(members.map((m) => [memberSlugFromRecord(m), m.role || 'Team Member']));
-  const metaByMember = new Map();
-  for (const m of members) {
-    const slug = memberSlugFromRecord(m);
-    const mDir = path.join(teamDir, slug);
-    const skills = listMemberUnlockedSkills(mDir, m.skills);
-    let goalWhy = null;
-    let goalTitle = null;
-    try {
-      const gp = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsFile: path.join(mDir, 'goals.json') });
-      goalWhy = gp?.goal?.why || null;
-      goalTitle = gp?.goal?.title || null;
-    } catch {}
-    metaByMember.set(slug, { skills, goalWhy, goalTitle });
-  }
   const filterMember = String(options.member || '').trim().toLowerCase();
   const limit = Number.isFinite(Number(options.limit)) && Number(options.limit) > 0 ? Number(options.limit) : 15;
 
-  const items = [];
-  const missionMap = memberRunMissionMap(root);
-  for (const mission of missionMap.values()) {
-    const owner = String(mission?.owner || '').trim();
-    if (!owner) continue;
-    if (filterMember && owner.toLowerCase() !== filterMember) continue;
-    const atIso = mission.last_tick_at || mission.updated_at || mission.created_at || null;
-    const atMs = timestampMs(atIso);
-    const summaryText = scrubFeedJargon(mission.last_summary || mission.objective || '');
-    if (!summaryText) continue;
-    const cleanSummary = compactSentence(summaryText, 140);
-    const verified = Boolean(mission?.verifier_result?.passed);
-    const meta = metaByMember.get(owner) || { skills: [], goalWhy: null, goalTitle: null };
-    const nextPush = scrubFeedJargon(mission.last_next_push || meta.goalTitle || '');
-    const impactChain = buildMemberImpactChain({
-      summary: cleanSummary,
-      verified,
-      goalWhy: meta.goalWhy,
-      nextPush,
-      skills: meta.skills,
-    });
-    items.push({
-      member: owner,
-      role: roleByMember.get(owner) || 'Team Member',
-      at: atIso,
-      at_ms: atMs,
-      age: ageLabelFromMs(atMs),
-      summary: cleanSummary,
-      status: plainFeedStatusLabel(mission),
-      verified,
-      next_push: impactChain.compounding,
-      impact_chain: impactChain,
-    });
+  const verifierByObjective = new Map();
+  for (const mission of memberRunMissionMap(root).values()) {
+    const objective = String(mission?.objective || '').trim();
+    if (objective && mission?.verifier) verifierByObjective.set(`${mission.owner}\u0000${objective}`, String(mission.verifier));
   }
 
+  const items = [];
   for (const record of members) {
     const slug = memberSlugFromRecord(record);
     if (filterMember && slug.toLowerCase() !== filterMember) continue;
     const logsDir = path.join(teamDir, slug, 'logs');
     if (!fs.existsSync(logsDir)) continue;
-    const logFiles = fs.readdirSync(logsDir).filter((f) => f.endsWith('.md')).sort().slice(-2);
+    const mDir = path.join(teamDir, slug);
+    let goalWhy = null;
+    try {
+      goalWhy = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsFile: path.join(mDir, 'goals.json') })?.goal?.why || null;
+    } catch {}
+    const skills = listMemberUnlockedSkills(mDir, record.skills);
+    const logFiles = fs.readdirSync(logsDir).filter((f) => f.endsWith('.md')).sort().slice(-7);
     for (const file of logFiles) {
       const fullPath = path.join(logsDir, file);
       let raw = '';
@@ -10038,42 +10036,45 @@ function collectMemberWorkFeed(root = process.cwd(), options = {}) {
       } catch {
         continue;
       }
-      const sections = raw.split(/^##\s+/m).slice(1);
-      for (const section of sections.slice(-3)) {
+      for (const section of raw.split(/^##\s+/m).slice(1)) {
         const lines = section.trim().split(/\r?\n/);
         const header = lines[0] || '';
-        const summaryLine = lines.find((l) => /^-\s*(summary|mission|title):/i.test(l));
-        const verifierLine = lines.find((l) => /^-\s*verifier:/i.test(l));
-        const nextPushLine = lines.find((l) => /^-\s*(next_push|next push|next):/i.test(l));
-        const rawSummary = summaryLine
-          ? summaryLine.replace(/^-\s*(summary|mission|title):\s*/i, '')
-          : header.replace(/^\d{2}:\d{2}\s*·\s*/, '');
+        const title = header.replace(/^\d{2}:\d{2}\s*·\s*/, '');
+        if (isFeedFillerText(title)) continue;
+        const field = (name) => {
+          const line = lines.find((l) => new RegExp(`^-\\s*${name}:`, 'i').test(l));
+          return line ? line.replace(new RegExp(`^-\\s*${name}:\\s*`, 'i'), '').trim() : '';
+        };
+        // No summary means nothing was recorded as changed: skip the row.
+        const rawSummary = field('summary');
+        if (isFeedFillerText(rawSummary)) continue;
         const cleanSummary = compactSentence(scrubFeedJargon(rawSummary), 140);
-        if (!cleanSummary) continue;
-        const alreadyInItems = items.some((item) => item.member === slug && item.summary === cleanSummary);
-        if (alreadyInItems) continue;
-        const passed = verifierLine ? /passed/i.test(verifierLine) : false;
-        const meta = metaByMember.get(slug) || { skills: [], goalWhy: null, goalTitle: null };
-        const rawNextPush = nextPushLine
-          ? nextPushLine.replace(/^-\s*(next_push|next push|next):\s*/i, '')
-          : (meta.goalTitle || '');
+        if (!cleanSummary || isFeedFillerText(cleanSummary)) continue;
+        if (items.some((item) => item.member === slug && item.summary === cleanSummary)) continue;
+        const verifierState = (field('verifier').match(/^(passed|failed)/i)?.[1] || '').toLowerCase();
+        const passed = verifierState === 'passed';
+        const verifierCommand = verifierByObjective.get(`${slug}\u0000${field('mission')}`) || '';
+        const rawNextPush = field('next_push') || field('next push');
+        const nextPush = isFeedFillerText(rawNextPush) ? '' : compactSentence(scrubFeedJargon(rawNextPush), 110);
+        const atMs = feedEntryTimeMs(file, header, mtimeMs);
         const impactChain = buildMemberImpactChain({
           summary: cleanSummary,
           verified: passed,
-          goalWhy: meta.goalWhy,
-          nextPush: rawNextPush,
-          skills: meta.skills,
+          goalWhy,
+          nextPush,
+          skills,
         });
         items.push({
           member: slug,
           role: record.role || 'Team Member',
-          at: new Date(mtimeMs).toISOString(),
-          at_ms: mtimeMs,
-          age: ageLabelFromMs(mtimeMs),
+          at: new Date(atMs).toISOString(),
+          at_ms: atMs,
+          age: ageLabelFromMs(atMs),
           summary: cleanSummary,
-          status: passed ? 'verified and ready' : 'logged update',
+          checked: plainFeedCheckLabel(verifierState, verifierCommand),
+          status: passed ? 'verified and ready' : verifierState === 'failed' ? 'check failed' : 'not checked yet',
           verified: passed,
-          next_push: impactChain.compounding,
+          next_push: nextPush || null,
           impact_chain: impactChain,
         });
       }
@@ -10085,6 +10086,14 @@ function collectMemberWorkFeed(root = process.cwd(), options = {}) {
     .slice(0, limit);
 }
 
+function formatMemberFeedRow(item, indent = '') {
+  const tail = item.next_push ? ` · next: ${item.next_push}` : '';
+  return [
+    `${indent}${item.age.padEnd(4)} · ${item.member}: ${item.summary}`,
+    `${indent}       ${item.checked}${tail}`,
+  ];
+}
+
 function memberFeed(...args) {
   if (hasFlag(args, '--help') || hasFlag(args, '-h')) {
     console.log('Usage: atris member feed [--member <name>] [--limit N] [--json]');
@@ -10096,14 +10105,8 @@ function memberFeed(...args) {
   const limit = readNumberFlag(args, '--limit', 15);
   const feed = collectMemberWorkFeed(process.cwd(), { member: memberFilter, limit });
   const lines = !feed.length
-    ? ['No team work recorded yet. Run: atris member dispatch "<idea>"']
-    : [
-        'Team work feed',
-        ...feed.flatMap((item) => [
-          `${item.age.padEnd(4)} · ${item.member} (${item.role}): ${item.summary} [${item.status}]`,
-          `       -> ${item.impact_chain.consequence} -> Next push: ${item.impact_chain.compounding}`,
-        ]),
-      ];
+    ? ['no real work yet']
+    : ['Team work feed', ...feed.flatMap((item) => formatMemberFeedRow(item))];
   printJsonOrText(
     {
       ok: true,
@@ -10499,16 +10502,21 @@ async function memberGo(...rawArgs) {
   const root = process.cwd();
   const teamDir = path.join(root, 'atris', 'team');
   const coreOrder = ['auto-improver', 'executor', 'navigator', 'validator', 'architect', 'customer-lead', 'researcher'];
-  let chosen = 'auto-improver';
+  let chosen = '';
   for (const slug of coreOrder) {
     const mDir = path.join(teamDir, slug);
     if (!fs.existsSync(path.join(mDir, 'MEMBER.md'))) continue;
-    const gp = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsFile: path.join(mDir, 'goals.json') });
+    if (!chosen) chosen = slug;
+    const gp = memberGoalPlaneStatus(slug, { memberDir: mDir, goalsJson: path.join(mDir, 'goals.json') });
     if (gp?.goal?.next_push || gp?.goal?.title) {
       chosen = slug;
       break;
     }
   }
+  if (!chosen) {
+    const fallback = findAllMembers(teamDir).filter(isFleetMember)[0];
+    if (fallback) chosen = memberSlugFromRecord(fallback);
+  }
   return memberSteerOrDispatch(chosen, ...rawArgs);
 }
 
@@ -10823,9 +10831,10 @@ async function memberRoom(...args) {
   if (hasFlag(args, '--walk') || Boolean(readFlag(args, '--decisions', ''))) {
     return memberStandupWalk(room, args);
   }
-  const engineSummary = room.engines.length
-    ? room.engines.map((e) => `${e.id}(${e.tier})`).join(', ')
-    : 'claude, codex';
+  const teamEngines = [...new Set(room.standup.map((s) => s.engine).filter((e) => e && e !== 'auto'))];
+  const engineLine = teamEngines.length
+    ? `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) => [
     `+-----------------------------------------------------------------------+`,
@@ -10844,16 +10853,12 @@ async function memberRoom(...args) {
     : ['  - Zero blocking 1-on-1s today. Every member has an active roadmap and engine seat.'];
 
   const feedRows = room.feed.length
-    ? room.feed.slice(0, 3).flatMap((item) => [
-        `  ${item.age.padEnd(4)} · ${item.member}: ${item.summary} [${item.status}]`,
-        `         -> ${item.impact_chain.consequence} -> Next push: ${item.impact_chain.compounding}`,
-      ])
-    : ['  No work recorded yet. Run: atris member go'];
+    ? room.feed.slice(0, 3).flatMap((item) => formatMemberFeedRow(item, '  '))
+    : ['  no real work yet'];
 
   const lines = [
     'Your team · workday briefing',
-    `Engines ready: ${engineSummary}`,
-    `Loop: ${room.utopia.loop}`,
+    engineLine,
     '',
     '1. Member-by-Member Standup (detail: `atris member card <name>` | rapid walk: `atris member standup --walk`):',
     ...standupRows,
@@ -10951,6 +10956,8 @@ async function memberCommand(subcommand, ...args) {
     case 'feed':
     case 'stream':
       return memberFeed(...args);
+    case 'board':
+      return require('../lib/member-board').memberBoardCommand(...args);
     case 'card':
     case 'cards':
       return memberCard(args[0], ...args.slice(1));
@@ -11010,6 +11017,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  1on1 <name>         Sit down for a 1-on-1 to review recent wins and set the roadmap');
       console.log('  sleep [name|--all]  Park active member loops so your team rests until woken');
       console.log('  room [--json]       Render the visual Team Room and desktop UI payload');
+      console.log('  board [--watch]     One screen of every member: job, last step, working/quiet/done');
       console.log('  create <name>       Scaffold a new team member (MEMBER.md + dirs) [--push]');
       console.log('  install <slug> [--update]  Install missing files, or refresh template skills');
       console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');

package/commands/mission.js

@@ -8,6 +8,7 @@ const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
 const { memberProcessPrompt } = require('../lib/member-context');
 const { memberIdentityLine, missionObjectiveLine } = require('../lib/member-identity');
+const { formatToolStep, appendProgress, reportProgress } = require('../lib/member-progress');
 const {
   compactErrorPayload,
   compactSuccessPayload,
@@ -9377,6 +9378,9 @@ function spawnClaudeTick(mission, opts) {
       env: { ...gitGuard.env, ATRIS_DISPATCH_DEPTH: String(dispatchDepth.depth + 1) },
     });
     updateMissionLockOwner(missionLock, proc.pid, { phase: 'tick' });
+    const progressMember = mission.owner || 'mission';
+    const seenToolIds = new Set();
+    appendProgress(progressMember, `started: ${mission.objective || ''}`, mission.id);
 
     let stdoutBuf = '';
     let observedSessionIds = new Set();
@@ -9417,6 +9421,14 @@ function spawnClaudeTick(mission, opts) {
         try {
           const ev = JSON.parse(line);
           if (ev.session_id) observedSessionIds.add(ev.session_id);
+          if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) {
+            for (const block of ev.message.content) {
+              const step = formatToolStep(block, cwd);
+              if (!step || seenToolIds.has(block.id)) continue;
+              if (block.id) seenToolIds.add(block.id);
+              reportProgress(progressMember, step, mission.id);
+            }
+          }
           if (ev.type === 'rate_limit_event' && ev.rate_limit_info) {
             rateLimitInfo = ev.rate_limit_info;
           }
@@ -9443,6 +9455,7 @@ function spawnClaudeTick(mission, opts) {
       if (signal) signal.removeEventListener?.('abort', onAbort);
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const ok = code === 0 && !isError && !timedOut && !aborted;
+      appendProgress(progressMember, `finished: ${ok ? 'ok' : 'failed'}`, mission.id);
       const errStr = stderr.slice(-2000);
       const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText, stdoutBuf);
       resolve({

package/commands/scoreboard.js

@@ -0,0 +1,132 @@
+'use strict';
+
+// atris scoreboard: today's GitHub contributions as a small game.
+// Data comes from `gh api graphql` (the contribution calendar) and `git log`
+// for this repo. Node built-ins only.
+
+const { execFileSync } = require('child_process');
+
+const QUERY = 'query { viewer { contributionsCollection { contributionCalendar { weeks { contributionDays { date contributionCount } } } } } }';
+const MEMBER_TRAILER = 'atris-builder[bot]@users.noreply.github.com';
+const BAR_WIDTH = 20;
+const CHEER_STEP = 50;
+
+function localDate(d = new Date()) {
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+function fetchDays() {
+  const out = execFileSync('gh', ['api', 'graphql', '-f', `query=${QUERY}`], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  const weeks = JSON.parse(out).data.viewer.contributionsCollection.contributionCalendar.weeks;
+  return weeks.flatMap((w) => w.contributionDays)
+    .map((d) => ({ date: d.date, count: d.contributionCount }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+}
+
+function score(days, today = localDate()) {
+  const todayDay = days.find((d) => d.date === today) || { date: today, count: 0 };
+  const year = today.slice(0, 4);
+  let best = null;
+  for (const d of days) {
+    if (d.date === today || !d.date.startsWith(year)) continue;
+    if (!best || d.count > best.count) best = d;
+  }
+  // A streak survives a quiet morning: if today is still zero, count from yesterday.
+  const past = days.filter((d) => d.date <= today);
+  if (past.length && past[past.length - 1].date === today && todayDay.count === 0) past.pop();
+  let streak = 0;
+  for (let i = past.length - 1; i >= 0 && past[i].count > 0; i--) streak++;
+  return { today: todayDay.count, best, streak };
+}
+
+function bar(count, target) {
+  const filled = Math.max(0, Math.min(BAR_WIDTH, Math.round((count / target) * BAR_WIDTH)));
+  return `[${'#'.repeat(filled)}${'-'.repeat(BAR_WIDTH - filled)}]`;
+}
+
+function repoCommits(cwd = process.cwd(), now = new Date()) {
+  const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  try {
+    const out = execFileSync('git', ['log', `--since=${midnight.toISOString()}`, '--format=%B%x1e'], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const bodies = out.split('\x1e').map((b) => b.trim()).filter(Boolean);
+    const members = bodies.filter((b) => b.includes(MEMBER_TRAILER)).length;
+    return { total: bodies.length, you: bodies.length - members, members };
+  } catch {
+    return null;
+  }
+}
+
+function render(s, commits) {
+  const lines = [`today: ${s.today} contribution${s.today === 1 ? '' : 's'}`];
+  if (s.best) {
+    const target = s.best.count + 1;
+    const note = s.today >= target ? 'new best day this year' : `${target - s.today} to beat your best`;
+    lines.push(`${bar(s.today, target)} ${note}`);
+    lines.push(`best day this year: ${s.best.date}, ${s.best.count}`);
+  } else {
+    lines.push('best day this year: none yet, today sets it');
+  }
+  lines.push(`streak: ${s.streak} day${s.streak === 1 ? '' : 's'}`);
+  lines.push(commits
+    ? `this repo today: ${commits.total} commit${commits.total === 1 ? '' : 's'}, you ${commits.you}, members ${commits.members}`
+    : 'this repo today: not a git repo');
+  return lines.join('\n');
+}
+
+// One cheer line per multiple of 50 crossed between two readings.
+function cheers(prev, next) {
+  const out = [];
+  for (let m = (Math.floor(prev / CHEER_STEP) + 1) * CHEER_STEP; m <= next; m += CHEER_STEP) {
+    out.push(`nice, you passed ${m} today. keep pushing.`);
+  }
+  return out;
+}
+
+function snapshot() {
+  const s = score(fetchDays());
+  return { s, text: render(s, repoCommits()) };
+}
+
+async function scoreboardCommand(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('usage: atris scoreboard [--watch]');
+    console.log('  today\'s github contributions, your best day this year, your streak, and this repo\'s commits');
+    console.log('  --watch   refresh every 60 seconds and cheer at every 50');
+    return 0;
+  }
+  let snap;
+  try {
+    snap = snapshot();
+  } catch {
+    console.error('could not read your github contributions. check that gh is installed and logged in (gh auth status).');
+    return 1;
+  }
+  console.log(snap.text);
+  if (!args.includes('--watch')) return 0;
+
+  const intervalMs = Number(process.env.ATRIS_SCOREBOARD_INTERVAL_MS) || 60000;
+  const maxTicks = Number(process.env.ATRIS_SCOREBOARD_TICKS) || Infinity;
+  let last = snap.s.today;
+  for (let tick = 0; tick < maxTicks; tick++) {
+    await new Promise((r) => setTimeout(r, intervalMs));
+    try {
+      snap = snapshot();
+    } catch {
+      console.log('refresh failed, trying again next minute');
+      continue;
+    }
+    console.log('');
+    console.log(snap.text);
+    for (const line of cheers(last, snap.s.today)) console.log(line);
+    last = snap.s.today;
+  }
+  return 0;
+}
+
+module.exports = { scoreboardCommand, score, render, cheers, bar, localDate };

package/lib/engine-registry.js

@@ -15,6 +15,21 @@ const {
   engineTakesModel,
   engineEffortLevels,
 } = require('./runner-command');
+// The one model-name table, shared with runner-command: friendly spellings
+// to the ids each cli accepts, plus retired-model upgrades.
+const {
+  CLAUDE_FAMILY_ENGINES,
+  CLAUDE_MODEL_ALIASES,
+  RETIRED_CLAUDE_MODELS,
+  CLAUDE_MODEL_SPELLING,
+  CLAUDE_LONG_CONTEXT,
+  GROK_MODEL_SPELLING,
+  currentClaudeModel,
+  claudeModelId,
+  retiredModelsNamed,
+  normalizeRosterModel,
+  savedRosterModel,
+} = require('./model-names');
 // Through the module object so tests can see when ranking runs.
 const routerBrain = require('./router-brain');
 const { routerPickExplanation } = routerBrain;
@@ -584,102 +599,6 @@ function rosterPickExpired(pick, now = new Date()) {
   return localDay(rosterDate(now)).getTime() > until.getTime();
 }
 
-// Claude-family engines run through the claude CLI, which rejects loose
-// spellings like "opus-5.5". Assign saves the id the CLI accepts, and every
-// read normalizes again, so older saved picks and hand edits work too.
-const CLAUDE_FAMILY_ENGINES = Object.freeze(['claude', 'fable', 'haiku']);
-const CLAUDE_MODEL_ALIASES = Object.freeze(['opus', 'sonnet', 'haiku', 'fable', 'opusplan', 'default']);
-// A retired model runs as its replacement, so a saved pick keeps working
-// after the upgrade. Retiring the next one is one line here.
-const RETIRED_CLAUDE_MODELS = Object.freeze({
-  'claude-fable-5': 'claude-fable-5-1',
-  'claude-haiku-4-5': 'claude-haiku-5-5',
-  'claude-haiku-4-5-20251001': 'claude-haiku-5-5',
-});
-const CLAUDE_MODEL_SPELLING = /^(opus|sonnet|haiku|fable)[\s_-]*(\d+)(?:[\s._-]+(\d+))?$/;
-const CLAUDE_LONG_CONTEXT = /\s*\[1m\]$/;
-
-// Grok takes friendly names too: "grok 4.7 fast" is grok-4.7-build-fast and
-// "grok 4.7" is grok-4.7. Any full grok- id passes through as typed.
-const GROK_MODEL_SPELLING = /^grok[\s_-]*(\d+(?:\.\d+)?)(?:[\s_-]+(?:build[\s_-]+)?(fast))?$/;
-
-function normalizeGrokModel(raw) {
-  const match = GROK_MODEL_SPELLING.exec(raw.toLowerCase());
-  if (match) return `grok-${match[1]}${match[2] ? '-build-fast' : ''}`;
-  if (/^grok-[a-z0-9][a-z0-9._-]*$/i.test(raw)) return raw;
-  throw new Error(`grok does not know the model "${raw}". use grok 4.7 fast, grok 4.7, or a full grok- id`);
-}
-
-// The model to run for a claude id: its replacement when it is retired,
-// else the id as given. Keeps a "[1m]" tail.
-function currentClaudeModel(value) {
-  const raw = String(value || '').trim();
-  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
-  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
-  const next = RETIRED_CLAUDE_MODELS[base.toLowerCase()];
-  return next ? `${next}${suffix}` : raw;
-}
-
-// The id the claude cli accepts for a display name typed with a space:
-// "opus 5.5" is claude-opus-5-5, "fable 5.1" is claude-fable-5-1. A full id,
-// a bare alias ("opus"), a "[1m]" tail and anything else pass through as given
-// (a retired id still becomes its replacement).
-const CLAUDE_DISPLAY_NAME = /^(opus|sonnet|haiku|fable)\s+(\d+)(?:\.(\d+))?$/i;
-
-function claudeModelId(value) {
-  const raw = String(value || '').trim();
-  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
-  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
-  const match = CLAUDE_DISPLAY_NAME.exec(base);
-  if (!match) return currentClaudeModel(raw);
-  return currentClaudeModel(`claude-${match[1].toLowerCase()}-${match[2]}${match[3] ? `-${match[3]}` : ''}${suffix}`);
-}
-
-// The retired models a roster file's text still names, by id or spelled
-// out, each once, so the roster can say they were upgraded.
-function retiredModelsNamed(text) {
-  const found = [];
-  for (const id of Object.keys(RETIRED_CLAUDE_MODELS)) {
-    const [, family, major, minor] = /^claude-([a-z]+)-(\d+)-(\d+)/.exec(id) || [];
-    if (!family) continue;
-    const spelled = new RegExp(`\\b(?:claude[\\s_-]*)?${family}[\\s_-]*${major}[\\s._-]+${minor}(?![\\d.])`, 'i');
-    const base = `claude-${family}-${major}-${minor}`;
-    if (spelled.test(String(text || '')) && !found.includes(base)) found.push(base);
-  }
-  return found;
-}
-
-function normalizeRosterModel(engineId, value) {
-  const raw = String(value || '').trim();
-  if (!raw) return '';
-  if (engineId === 'grok') return normalizeGrokModel(raw);
-  if (!CLAUDE_FAMILY_ENGINES.includes(engineId)) return raw;
-  // "[1m]" asks the claude cli for the long context window; keep it on
-  // whatever name it follows.
-  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
-  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
-  const lower = base.toLowerCase();
-  if (CLAUDE_MODEL_ALIASES.includes(lower)) return `${lower}${suffix}`;
-  const match = CLAUDE_MODEL_SPELLING.exec(lower.replace(/^claude[\s_-]*/, ''));
-  if (match) {
-    const id = `claude-${match[1]}-${match[2]}${match[3] ? `-${match[3]}` : ''}`;
-    return currentClaudeModel(`${id}${suffix}`);
-  }
-  if (lower.startsWith('claude-')) return currentClaudeModel(`${base}${suffix}`);
-  throw new Error(`${engineId} does not know the model "${raw}". use opus, sonnet, haiku, fable, opusplan, default, a version like opus 5.5, sonnet 5, haiku 5.5, or fable 5.1, or a full claude- id; add [1m] for the long context window`);
-}
-
-// A saved pick's model, normalized the same way assign does. null means the
-// saved name is one the claude cli would reject, so the pick cannot run.
-function savedRosterModel(engineId, value) {
-  try {
-    return normalizeRosterModel(engineId, value);
-  } catch {
-    return null;
-  }
-}
-
-
 // A registry saved before an engine learned a job keeps its old role list;
 // the roster still honors the job the engine can do today, including a job
 // it only takes by roster pick.

package/lib/known-commands.js

@@ -3,7 +3,7 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'sync-checkout',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi'];
 

package/lib/member-board.js

@@ -0,0 +1,129 @@
+'use strict';
+
+// One screen of every member with a progress log: what job it is on, its last
+// step, how long ago that was, and whether it is working, quiet, or done.
+// Reads the logs lib/member-progress.js writes: "<iso> <mission> <text>".
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const QUIET_AFTER_MS = 2 * 60 * 1000;
+const TAIL_BYTES = 256 * 1024;
+const JOB_WIDTH = 50;
+const STEP_WIDTH = 50;
+
+function progressDir() {
+  return process.env.ATRIS_PROGRESS_DIR || path.join(os.homedir(), '.atris', 'progress');
+}
+
+function readTail(file) {
+  const fd = fs.openSync(file, 'r');
+  try {
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - TAIL_BYTES);
+    const buf = Buffer.alloc(size - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    const text = buf.toString('utf8');
+    // A cut read starts mid-line; drop the partial first line.
+    return start > 0 ? text.slice(text.indexOf('\n') + 1) : text;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parseLine(raw) {
+  const m = /^(\S+) (\S+) (.*)$/.exec(raw);
+  if (!m) return null;
+  const at = Date.parse(m[1]);
+  if (Number.isNaN(at)) return null;
+  return { at, text: m[3] };
+}
+
+function cut(text, width) {
+  const s = String(text || '').replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 3)}...` : s;
+}
+
+function ago(ms) {
+  const s = Math.max(0, Math.floor(ms / 1000));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+}
+
+// The current run is everything from the latest "started:" line on.
+function memberRow(name, text, now) {
+  const lines = text.split('\n').map(parseLine).filter(Boolean);
+  if (!lines.length) return null;
+  let start = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].text.startsWith('started:')) { start = i; break; }
+  }
+  const run = lines.slice(start);
+  const startedLine = run[0].text.startsWith('started:') ? run[0] : null;
+  const finished = [...run].reverse().find((l) => l.text.startsWith('finished:'));
+  const step = [...run].reverse().find((l) => !l.text.startsWith('started:') && !l.text.startsWith('finished:'));
+  const last = run[run.length - 1];
+  let state;
+  if (finished) state = /^finished:\s*ok\b/.test(finished.text) ? 'done ok' : 'done failed';
+  else state = now - last.at < QUIET_AFTER_MS ? 'working' : 'quiet';
+  return {
+    member: name,
+    state,
+    job: startedLine ? cut(startedLine.text.slice('started:'.length), JOB_WIDTH) : '',
+    step: step ? cut(step.text, STEP_WIDTH) : '',
+    ago: ago(now - last.at),
+    at: last.at,
+  };
+}
+
+function readBoard({ dir = progressDir(), now = Date.now() } = {}) {
+  let files = [];
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch {}
+  const rows = [];
+  for (const f of files) {
+    let text = '';
+    try { text = readTail(path.join(dir, f)); } catch { continue; }
+    const row = memberRow(f.slice(0, -'.log'.length), text, now);
+    if (row) rows.push(row);
+  }
+  return rows.sort((a, b) => b.at - a.at);
+}
+
+function renderBoard(rows, dir = progressDir()) {
+  if (!rows.length) return `no member progress yet in ${dir}`;
+  const w = (key, min) => Math.max(min, ...rows.map((r) => r[key].length));
+  const nameW = w('member', 6);
+  const stateW = w('state', 5);
+  const agoW = w('ago', 3);
+  const jobW = Math.max(3, ...rows.map((r) => (r.job || '-').length));
+  const pad = (s, n) => s.padEnd(n);
+  const line = (a, b, c, d, e) => `${pad(a, nameW)}  ${pad(b, stateW)}  ${pad(c, agoW)}  ${pad(d, jobW)}  ${e}`.trimEnd();
+  const out = [line('member', 'state', 'ago', 'job', 'last step')];
+  for (const r of rows) out.push(line(r.member, r.state, r.ago, r.job || '-', r.step || '-'));
+  return out.join('\n');
+}
+
+function memberBoardCommand(...args) {
+  const asJson = args.includes('--json');
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard() }, null, 2));
+    return;
+  }
+  const draw = () => renderBoard(readBoard());
+  if (!args.includes('--watch')) {
+    console.log(draw());
+    return;
+  }
+  const redraw = () => process.stdout.write(`\x1b[2J\x1b[H${draw()}\n\nredraws every 3s, ctrl-c to stop\n`);
+  redraw();
+  // The member route exits once this settles, so only settle on ctrl-c.
+  return new Promise((resolve) => {
+    const timer = setInterval(redraw, 3000);
+    process.once('SIGINT', () => { clearInterval(timer); resolve(); });
+  });
+}
+
+module.exports = { readBoard, renderBoard, memberRow, ago, memberBoardCommand };

package/lib/member-progress.js

@@ -0,0 +1,82 @@
+'use strict';
+
+// Live progress for a working member: one plain line per tool step, printed to
+// stderr and appended to <dir>/<member>.log so another shell can tail it.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function realish(p) {
+  try { return fs.realpathSync(p); } catch {}
+  try { return path.join(fs.realpathSync(path.dirname(p)), path.basename(p)); } catch {}
+  return p;
+}
+
+function insideRel(cwd, p) {
+  const rel = path.relative(cwd, p);
+  return rel && !rel.startsWith('..') && !path.isAbsolute(rel) ? rel : null;
+}
+
+// Relative to cwd when inside it; symlinked roots (macOS /var vs /private/var)
+// still count as inside.
+function relativeTo(cwd, file) {
+  const p = String(file || '');
+  if (!p || !cwd || !path.isAbsolute(p)) return p;
+  return insideRel(cwd, p) || insideRel(realish(cwd), realish(p)) || p;
+}
+
+function formatToolStep(block, cwd) {
+  if (!block || block.type !== 'tool_use') return null;
+  const name = String(block.name || 'tool');
+  const input = block.input || {};
+  switch (name) {
+    case 'Read':
+      return `reading ${relativeTo(cwd, input.file_path)}`;
+    case 'Edit':
+    case 'MultiEdit':
+    case 'Write':
+      return `editing ${relativeTo(cwd, input.file_path)}`;
+    case 'Bash': {
+      const first = String(input.command || '').split('\n')[0].trim();
+      return `running: ${first.slice(0, 70)}`;
+    }
+    case 'Grep':
+      return `searching for ${input.pattern || ''}`;
+    case 'Glob':
+      return `finding ${input.pattern || ''}`;
+    default:
+      return name.toLowerCase();
+  }
+}
+
+function progressDir() {
+  return process.env.ATRIS_PROGRESS_DIR || path.join(os.homedir(), '.atris', 'progress');
+}
+
+function safeMember(member) {
+  return String(member || 'mission').replace(/[^A-Za-z0-9._-]/g, '_') || 'mission';
+}
+
+function hhmm(date = new Date()) {
+  return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+
+function appendProgress(member, line, missionId) {
+  // Test runs never write into the real home folder unless they name a dir.
+  if (!process.env.ATRIS_PROGRESS_DIR && process.env.NODE_TEST_CONTEXT) return;
+  try {
+    const dir = progressDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const entry = `${new Date().toISOString()} ${missionId || '-'} ${line}\n`;
+    fs.appendFileSync(path.join(dir, `${safeMember(member)}.log`), entry, 'utf8');
+  } catch {}
+}
+
+// Print one step for the operator and keep it in the member's progress log.
+function reportProgress(member, line, missionId) {
+  try { process.stderr.write(`  ${member || 'mission'} ${hhmm()}  ${line}\n`); } catch {}
+  appendProgress(member, line, missionId);
+}
+
+module.exports = { formatToolStep, appendProgress, reportProgress };

package/lib/model-names.js

@@ -0,0 +1,116 @@
+'use strict';
+
+// Friendly model names to the ids each engine's cli accepts. This is the ONE
+// table of spellings: engine-registry checks roster picks with it and
+// runner-command normalizes launch models with it. "opus 5.5" is
+// claude-opus-5-5, "grok 4.7 fast" is grok-4.7-build-fast. Kept free of
+// requires so both files can load it without a circular dependency.
+
+// Claude-family engines run through the claude CLI, which rejects loose
+// spellings like "opus-5.5". Assign saves the id the CLI accepts, and every
+// read normalizes again, so older saved picks and hand edits work too.
+const CLAUDE_FAMILY_ENGINES = Object.freeze(['claude', 'fable', 'haiku']);
+const CLAUDE_MODEL_ALIASES = Object.freeze(['opus', 'sonnet', 'haiku', 'fable', 'opusplan', 'default']);
+// A retired model runs as its replacement, so a saved pick keeps working
+// after the upgrade. Retiring the next one is one line here.
+const RETIRED_CLAUDE_MODELS = Object.freeze({
+  'claude-fable-5': 'claude-fable-5-1',
+  'claude-haiku-4-5': 'claude-haiku-5-5',
+  'claude-haiku-4-5-20251001': 'claude-haiku-5-5',
+});
+const CLAUDE_MODEL_SPELLING = /^(opus|sonnet|haiku|fable)[\s_-]*(\d+)(?:[\s._-]+(\d+))?$/;
+const CLAUDE_LONG_CONTEXT = /\s*\[1m\]$/;
+
+// Grok takes friendly names too: "grok 4.7 fast" is grok-4.7-build-fast and
+// "grok 4.7" is grok-4.7. Any full grok- id passes through as typed.
+const GROK_MODEL_SPELLING = /^grok[\s_-]*(\d+(?:\.\d+)?)(?:[\s_-]+(?:build[\s_-]+)?(fast))?$/;
+
+function normalizeGrokModel(raw) {
+  const match = GROK_MODEL_SPELLING.exec(raw.toLowerCase());
+  if (match) return `grok-${match[1]}${match[2] ? '-build-fast' : ''}`;
+  if (/^grok-[a-z0-9][a-z0-9._-]*$/i.test(raw)) return raw;
+  throw new Error(`grok does not know the model "${raw}". use grok 4.7 fast, grok 4.7, or a full grok- id`);
+}
+
+// The model to run for a claude id: its replacement when it is retired,
+// else the id as given. Keeps a "[1m]" tail.
+function currentClaudeModel(value) {
+  const raw = String(value || '').trim();
+  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
+  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
+  const next = RETIRED_CLAUDE_MODELS[base.toLowerCase()];
+  return next ? `${next}${suffix}` : raw;
+}
+
+// The id the claude cli accepts for a display name typed with a space:
+// "opus 5.5" is claude-opus-5-5, "fable 5.1" is claude-fable-5-1. A full id,
+// a bare alias ("opus"), a "[1m]" tail and anything else pass through as given
+// (a retired id still becomes its replacement).
+const CLAUDE_DISPLAY_NAME = /^(opus|sonnet|haiku|fable)\s+(\d+)(?:\.(\d+))?$/i;
+
+function claudeModelId(value) {
+  const raw = String(value || '').trim();
+  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
+  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
+  const match = CLAUDE_DISPLAY_NAME.exec(base);
+  if (!match) return currentClaudeModel(raw);
+  return currentClaudeModel(`claude-${match[1].toLowerCase()}-${match[2]}${match[3] ? `-${match[3]}` : ''}${suffix}`);
+}
+
+// The retired models a roster file's text still names, by id or spelled
+// out, each once, so the roster can say they were upgraded.
+function retiredModelsNamed(text) {
+  const found = [];
+  for (const id of Object.keys(RETIRED_CLAUDE_MODELS)) {
+    const [, family, major, minor] = /^claude-([a-z]+)-(\d+)-(\d+)/.exec(id) || [];
+    if (!family) continue;
+    const spelled = new RegExp(`\\b(?:claude[\\s_-]*)?${family}[\\s_-]*${major}[\\s._-]+${minor}(?![\\d.])`, 'i');
+    const base = `claude-${family}-${major}-${minor}`;
+    if (spelled.test(String(text || '')) && !found.includes(base)) found.push(base);
+  }
+  return found;
+}
+
+function normalizeRosterModel(engineId, value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  if (engineId === 'grok') return normalizeGrokModel(raw);
+  if (!CLAUDE_FAMILY_ENGINES.includes(engineId)) return raw;
+  // "[1m]" asks the claude cli for the long context window; keep it on
+  // whatever name it follows.
+  const suffix = CLAUDE_LONG_CONTEXT.test(raw) ? '[1m]' : '';
+  const base = raw.replace(CLAUDE_LONG_CONTEXT, '').trim();
+  const lower = base.toLowerCase();
+  if (CLAUDE_MODEL_ALIASES.includes(lower)) return `${lower}${suffix}`;
+  const match = CLAUDE_MODEL_SPELLING.exec(lower.replace(/^claude[\s_-]*/, ''));
+  if (match) {
+    const id = `claude-${match[1]}-${match[2]}${match[3] ? `-${match[3]}` : ''}`;
+    return currentClaudeModel(`${id}${suffix}`);
+  }
+  if (lower.startsWith('claude-')) return currentClaudeModel(`${base}${suffix}`);
+  throw new Error(`${engineId} does not know the model "${raw}". use opus, sonnet, haiku, fable, opusplan, default, a version like opus 5.5, sonnet 5, haiku 5.5, or fable 5.1, or a full claude- id; add [1m] for the long context window`);
+}
+
+// A saved pick's model, normalized the same way assign does. null means the
+// saved name is one the claude cli would reject, so the pick cannot run.
+function savedRosterModel(engineId, value) {
+  try {
+    return normalizeRosterModel(engineId, value);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  CLAUDE_FAMILY_ENGINES,
+  CLAUDE_MODEL_ALIASES,
+  RETIRED_CLAUDE_MODELS,
+  CLAUDE_MODEL_SPELLING,
+  CLAUDE_LONG_CONTEXT,
+  GROK_MODEL_SPELLING,
+  currentClaudeModel,
+  claudeModelId,
+  retiredModelsNamed,
+  normalizeRosterModel,
+  savedRosterModel,
+};

package/lib/runner-command.js

@@ -16,19 +16,20 @@ const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
 const EFFORT_WORDS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
 const CLAUDE_EFFORTS = EFFORT_WORDS;
 
-const FRIENDLY_CLAUDE_MODEL_ALIASES = Object.freeze({
-  'opus 5.5': 'claude-opus-5-5',
-  'opus-5.5': 'claude-opus-5-5',
-  'opus 5': 'claude-opus-5',
-  'opus-5': 'claude-opus-5',
-  'opus 4.8': 'claude-opus-4-8',
-  'opus-4.8': 'claude-opus-4-8',
-});
+// The one model-name table lives in model-names.js, shared with
+// engine-registry. Friendly names become the ids the claude cli accepts;
+// anything it does not know passes through unchanged (runners like glm and
+// swe name their own models here, so this never throws).
+const { claudeModelId, currentClaudeModel, normalizeRosterModel } = require('./model-names');
 
 function normalizeClaudeModelName(value) {
   const trimmed = String(value || '').trim();
   if (!trimmed) return '';
-  return FRIENDLY_CLAUDE_MODEL_ALIASES[trimmed.toLowerCase()] || trimmed;
+  try {
+    return normalizeRosterModel('claude', trimmed);
+  } catch {
+    return trimmed;
+  }
 }
 
 // Canonical runner profiles. Each entry is the config an operator would pick
@@ -246,7 +247,7 @@ function ownModelsOnlyEngineForBin(bin) {
 // claude env pin) and rides its own default instead.
 function runnerModelFor(engineId, model) {
   // Required here, not at the top: engine-registry requires this file.
-  const { isClaudeFamilyModel, currentClaudeModel, claudeModelId } = require('./engine-registry');
+  const { isClaudeFamilyModel } = require('./engine-registry');
   const name = String(engineId || '').trim().toLowerCase();
   // A display name like "opus 5.5" only becomes an id for the claude cli (or
   // an unnamed engine). Any other engine's model name is handed over as is.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.68.4",
+  "version": "3.68.6",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {