atris 3.68.6 → 3.68.7

package/bin/atris.js

@@ -630,7 +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('  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');

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)

package/commands/scoreboard.js

@@ -48,13 +48,21 @@ function bar(count, target) {
   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', `--since=${midnight.toISOString()}`, '--format=%B%x1e'], {
+    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 bodies = out.split('\x1e').map((b) => b.trim()).filter(Boolean);
+    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 {
@@ -90,14 +98,21 @@ function cheers(prev, next) {
 
 function snapshot() {
   const s = score(fetchDays());
-  return { s, text: render(s, repoCommits()) };
+  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]');
+    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;
@@ -107,6 +122,10 @@ async function scoreboardCommand(args = []) {
     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;
 
@@ -129,4 +148,4 @@ async function scoreboardCommand(args = []) {
   return 0;
 }
 
-module.exports = { scoreboardCommand, score, render, cheers, bar, localDate };
+module.exports = { scoreboardCommand, score, render, toJson, cheers, bar, localDate };

package/lib/member-board.js

@@ -9,6 +9,7 @@ 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;
@@ -53,7 +54,13 @@ function ago(ms) {
   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;
@@ -64,7 +71,10 @@ function memberRow(name, text, now) {
   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 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';
@@ -76,10 +86,12 @@ function memberRow(name, text, now) {
     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() } = {}) {
+function readBoard({ dir = progressDir(), now = Date.now(), all = false } = {}) {
   let files = [];
   try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch {}
   const rows = [];
@@ -89,11 +101,12 @@ function readBoard({ dir = progressDir(), now = Date.now() } = {}) {
     const row = memberRow(f.slice(0, -'.log'.length), text, now);
     if (row) rows.push(row);
   }
-  return rows.sort((a, b) => b.at - a.at);
+  return rows.filter((r) => all || !r.idle).sort((a, b) => b.at - a.at);
 }
 
-function renderBoard(rows, dir = progressDir()) {
-  if (!rows.length) return `no member progress yet in ${dir}`;
+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);
@@ -103,16 +116,137 @@ function renderBoard(rows, dir = progressDir()) {
   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() }, null, 2));
+    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard({ all }) }, null, 2));
     return;
   }
-  const draw = () => renderBoard(readBoard());
+  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;
@@ -126,4 +260,4 @@ function memberBoardCommand(...args) {
   });
 }
 
-module.exports = { readBoard, renderBoard, memberRow, ago, memberBoardCommand };
+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.6",
+  "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": {