atris 3.68.5 → 3.68.7

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, --json)');
   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

@@ -1300,6 +1300,13 @@ function memberRunWith(name, args, { quiet = false } = {}) {
     if (nodeModulesLinked) console.log(`linked node_modules from ${nodeModulesSource}`);
   }
 
+  // An ignited run works for minutes; say where to watch it before it starts.
+  if (ignite && !asJson && !quiet && !hasFlag(args, '--quiet')) {
+    const progressDir = process.env.ATRIS_PROGRESS_DIR || '~/.atris/progress';
+    console.log(`watch: tail -f ${progressDir}/${String(name).replace(/[^A-Za-z0-9._-]/g, '_')}.log`);
+    console.log('board: atris member board --watch');
+  }
+
   const cwd = mission.worktree?.path || process.cwd();
   const verifier = readFlag(args, '--verify', '') || mission.verifier || requestedVerifier;
   if (verifier && verifier !== mission.verifier) {
@@ -9789,6 +9796,17 @@ const IDEA_ARCHETYPE_RULES = [
   },
 ];
 
+// Dispatch defaults to the core team. Other members (experiments, one-off
+// workers) win only when the idea names them or out-scores the core by 2x.
+const CORE_DISPATCH_MEMBERS = new Set([
+  'executor', 'architect', 'auto-improver', 'navigator', 'validator', 'customer-lead', 'researcher',
+]);
+
+function ideaNamesMember(text, slug) {
+  const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/-/g, '[-\\s]+');
+  return new RegExp(`(^|[^a-z0-9-])${escaped}($|[^a-z0-9-])`, 'i').test(text);
+}
+
 function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '') {
   const teamDir = path.join(root, 'atris', 'team');
   const members = findAllMembers(teamDir).filter(isFleetMember);
@@ -9841,6 +9859,13 @@ function pickMemberForIdea(ideaText, root = process.cwd(), preferredMember = '')
     if (slug === 'executor') score += 3;
     if (slug === 'auto-improver') score += 2;
 
+    if (ideaNamesMember(text, slug)) {
+      score += 40;
+      matchedReason = 'named in the idea';
+    } else if (!CORE_DISPATCH_MEMBERS.has(slug)) {
+      score = Math.floor(score / 2);
+    }
+
     if (!matchedReason) {
       matchedReason = record.description
         ? compactSentence(record.description, 90)
@@ -9937,6 +9962,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 +9992,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 +10061,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 +10111,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 +10130,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,
@@ -10828,9 +10856,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) => [
     `+-----------------------------------------------------------------------+`,
@@ -10849,16 +10878,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,
@@ -10956,6 +10981,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));
@@ -11015,6 +11042,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/scoreboard.js

@@ -0,0 +1,151 @@
+'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)}]`;
+}
+
+// Today's commits on every ref (all local and remote branches, the checkout,
+// tags), so an old branch checked out still sees today's work. Stash is left
+// out. Each commit counts once, keyed by hash.
+function repoCommits(cwd = process.cwd(), now = new Date()) {
+  const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  try {
+    const out = execFileSync('git', ['log', '--exclude=refs/stash', '--all', `--since=${midnight.toISOString()}`, '--format=%H%x1f%B%x1e'], {
+      cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const byHash = new Map();
+    for (const rec of out.split('\x1e')) {
+      const [hash, body = ''] = rec.trim().split('\x1f');
+      if (hash) byHash.set(hash, body);
+    }
+    const bodies = [...byHash.values()];
+    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());
+  const commits = repoCommits();
+  return { s, commits, text: render(s, commits) };
+}
+
+// Same numbers as the board, as one object for scripts.
+function toJson(s, commits, date = localDate()) {
+  return { date, today: s.today, best: s.best, streak: s.streak, repo: commits };
+}
+
+async function scoreboardCommand(args = []) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('usage: atris scoreboard [--watch | --json]');
+    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');
+    console.log('  --json    print the same numbers once as one json object');
+    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;
+  }
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(toJson(snap.s, snap.commits), null, 2));
+    return 0;
+  }
+  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, toJson, cheers, bar, localDate };

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,263 @@
+'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 HIDE_DONE_AFTER_MS = 60 * 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`;
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// The current run is everything from the latest "started:" line on.
+// Steps that only write the member's own log are housekeeping, so the last
+// step column skips them unless nothing else happened.
+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 ownLog = new RegExp(`atris/team/${escapeRe(name)}/logs\\b`);
+  const steps = run.filter((l) => !l.text.startsWith('started:') && !l.text.startsWith('finished:'));
+  const real = steps.filter((l) => !ownLog.test(l.text));
+  const step = real[real.length - 1] || steps[steps.length - 1];
+  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,
+    // Finished more than an hour ago: off the board unless --all.
+    idle: last.text.startsWith('finished:') && now - last.at >= HIDE_DONE_AFTER_MS,
+  };
+}
+
+function readBoard({ dir = progressDir(), now = Date.now(), all = false } = {}) {
+  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.filter((r) => all || !r.idle).sort((a, b) => b.at - a.at);
+}
+
+function renderBoard(rows, dir = progressDir(), hidden = 0) {
+  const note = hidden ? `${hidden} finished over an hour ago, hidden. --all shows them` : '';
+  if (!rows.length) return note ? `nobody is working right now. ${note}` : `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 || '-'));
+  if (note) out.push('', note);
+  return out.join('\n');
+}
+
+// Live stream format for `atris member board --json --follow`, one JSON
+// object per line on stdout, forever:
+//   first line: {"kind":"snapshot","at":"<iso>","dir":"<progress dir>","members":[<same rows as --json>]}
+//   then one line per new progress line, in the order it was read:
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"started","text":"<job>"}
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"step","text":"<step>"}
+//     {"member":"builder","mission":"m-1","at":"<iso>","kind":"finished","text":"ok","ok":true}
+// "ok" appears only on finished. Lines that are not "<iso> <mission> <text>"
+// are skipped, and a line is only read once its newline has been written.
+// Stops on ctrl-c, or on the next write after the reader closes the pipe;
+// an app that is done should kill the process.
+function progressEvent(member, raw) {
+  const m = /^(\S+) (\S+) (.*)$/.exec(raw);
+  if (!m) return null;
+  const at = Date.parse(m[1]);
+  if (Number.isNaN(at)) return null;
+  const event = { member, mission: m[2], at: new Date(at).toISOString(), kind: 'step', text: m[3] };
+  const tagged = /^(started|finished):\s*(.*)$/.exec(m[3]);
+  if (tagged) {
+    event.kind = tagged[1];
+    event.text = tagged[2];
+    if (tagged[1] === 'finished') event.ok = /^ok\b/.test(tagged[2]);
+  }
+  return event;
+}
+
+// Tails every <member>.log in dir and calls emit(event) for each new full
+// line. Files present at start are read from just after their last newline,
+// so a line half written before the stream started still arrives once done;
+// files that appear later are read from the top. scan() is sync, so watch
+// and poll can both call it without racing.
+function afterLastNewline(file) {
+  let fd;
+  try { fd = fs.openSync(file, 'r'); } catch { return 0; }
+  try {
+    const buf = Buffer.alloc(64 * 1024);
+    for (let end = fs.fstatSync(fd).size; end > 0;) {
+      const start = Math.max(0, end - buf.length);
+      const n = fs.readSync(fd, buf, 0, end - start, start);
+      const i = buf.subarray(0, n).lastIndexOf(0x0a);
+      if (i >= 0) return start + i + 1;
+      end = start;
+    }
+    return 0;
+  } catch { return 0; } finally { fs.closeSync(fd); }
+}
+
+function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
+  const offsets = new Map();
+  const sizeOf = (file) => { try { return fs.statSync(file).size; } catch { return null; } };
+  const list = () => { try { return fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch { return []; } };
+  for (const f of list()) offsets.set(f, afterLastNewline(path.join(dir, f)));
+
+  function readNew(f) {
+    const file = path.join(dir, f);
+    const size = sizeOf(file);
+    if (size === null) return;
+    let from = offsets.get(f) || 0;
+    if (size < from) from = 0; // truncated or replaced: start over
+    if (size === from) { offsets.set(f, from); return; }
+    let buf;
+    try {
+      const fd = fs.openSync(file, 'r');
+      try {
+        buf = Buffer.alloc(size - from);
+        buf = buf.subarray(0, fs.readSync(fd, buf, 0, buf.length, from));
+      } finally { fs.closeSync(fd); }
+    } catch { return; }
+    // Stop at the last newline; a half-written tail waits for the next scan.
+    const end = buf.lastIndexOf(0x0a);
+    if (end < 0) { offsets.set(f, from); return; }
+    offsets.set(f, from + end + 1);
+    const member = f.slice(0, -'.log'.length);
+    for (const raw of buf.subarray(0, end).toString('utf8').split('\n')) {
+      const event = progressEvent(member, raw.replace(/\r$/, ''));
+      if (event) emit(event);
+    }
+  }
+
+  let watcher = null;
+  let stopped = false;
+  function scan() {
+    if (stopped) return;
+    if (!watcher) {
+      try {
+        watcher = fs.watch(dir, () => scan());
+        watcher.on('error', () => { try { watcher.close(); } catch {} watcher = null; });
+      } catch { watcher = null; }
+    }
+    for (const f of list()) readNew(f);
+  }
+  const timer = setInterval(scan, pollMs);
+  scan();
+  return {
+    scan,
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+      if (watcher) { try { watcher.close(); } catch {} }
+    },
+  };
+}
+
+function memberBoardCommand(...args) {
+  const asJson = args.includes('--json');
+  const all = args.includes('--all');
+  if (args.includes('--follow')) {
+    const dir = progressDir();
+    const write = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
+    write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all }) });
+    const follower = followBoard({ dir, emit: write });
+    // Runs until ctrl-c or the reader closes the pipe.
+    return new Promise((resolve) => {
+      const done = () => { follower.stop(); resolve(); };
+      process.once('SIGINT', done);
+      process.stdout.once('error', done);
+    });
+  }
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard({ all }) }, null, 2));
+    return;
+  }
+  const draw = () => {
+    const every = readBoard({ all: true });
+    const rows = all ? every : every.filter((r) => !r.idle);
+    return renderBoard(rows, progressDir(), every.length - rows.length);
+  };
+  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, progressEvent, followBoard, memberBoardCommand };

package/lib/member-progress.js

@@ -62,21 +62,33 @@ function hhmm(date = new Date()) {
   return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
 }
 
+// One progress line stays one short line: a 'started:' objective keeps its
+// first line and at most 80 chars; any other line caps at 100.
+function shortenLine(line) {
+  const first = String(line || '').split('\n')[0];
+  if (first.startsWith('started: ')) {
+    const objective = first.slice('started: '.length);
+    return `started: ${objective.length > 80 ? `${objective.slice(0, 80)}...` : objective}`;
+  }
+  return first.length > 100 ? `${first.slice(0, 100)}...` : first;
+}
+
 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`;
+    const entry = `${new Date().toISOString()} ${missionId || '-'} ${shortenLine(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);
+  const short = shortenLine(line);
+  try { process.stderr.write(`  ${member || 'mission'} ${hhmm()}  ${short}\n`); } catch {}
+  appendProgress(member, short, missionId);
 }
 
-module.exports = { formatToolStep, appendProgress, reportProgress };
+module.exports = { formatToolStep, appendProgress, reportProgress, shortenLine };

package/package.json

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