atris 3.64.0 → 3.65.0

package/lib/roster-stale.js

@@ -0,0 +1,241 @@
+'use strict';
+
+// Outdated models on the roster. A roster worker whose model has a newer
+// version among the models this machine or the engine registry already
+// knows gets one plain line and the command that moves it forward. A pinned
+// model whose newest proof (a "verified <date>" on its line, or a landed run
+// on that model) is over 30 days old gets one line too. Nothing here goes
+// online: the model lists come from availableModels (codex's own models
+// cache, the claude names atris knows, and each engine's registry models).
+
+const { modelLabel, availableModels } = require('./roster-models');
+const { parseRosterUntil, rosterMaxText, rosterToolLabel } = require('./engine-registry');
+
+const PIN_MAX_AGE_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+
+// Family ordering across names is ambiguous: going from a "luna" tail to a
+// "sol" tail one version up is a tier change as much as a version change,
+// and nothing local says which tails rank above which. So versions are only
+// compared within an identical name prefix, the text before the first
+// version number: "x-6-astra" and "x-6.1-sol" share the prefix "x", and two
+// names with different prefixes (sonnet and opus) never compare. Among
+// newer versions, one that keeps the same tail (sol, fast, flash-high) wins;
+// otherwise the highest version, and on a tie the one the list names first.
+// Examples stay abstract here so this file never pins a real model name.
+// A context tag at the end ("[1m]", "(beta)") is not part of the name, and
+// a leading "claude-" before a family word is the vendor, not the family,
+// so "claude-x-4-6[1m]" and "x 5" land in the same family.
+function familyLabel(model) {
+  let text = String(model || '').trim();
+  while (/\s*(?:\[[^\]]*\]|\([^)]*\))$/.test(text)) text = text.replace(/\s*(?:\[[^\]]*\]|\([^)]*\))$/, '');
+  return modelLabel(text).toLowerCase().trim().replace(/^claude[\s_-]+(?=[a-z])/, '');
+}
+
+function modelFamily(model) {
+  const label = familyLabel(model);
+  const match = /^([a-z][a-z/_\s-]*?)[\s_-]*(\d+(?:[.-]\d{1,2}(?!\d))*)(.*)$/.exec(label);
+  if (!match) return null;
+  const prefix = match[1].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (!prefix) return null;
+  return {
+    prefix,
+    version: match[2].split(/[.-]/).map(Number),
+    variant: match[3].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, ''),
+  };
+}
+
+function compareVersions(a, b) {
+  const size = Math.max(a.length, b.length);
+  for (let i = 0; i < size; i += 1) {
+    const diff = (a[i] || 0) - (b[i] || 0);
+    if (diff) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function sameModel(a, b) {
+  const left = modelLabel(a).toLowerCase().trim();
+  return Boolean(left) && left === modelLabel(b).toLowerCase().trim();
+}
+
+// The newest model in the list that beats this one, or null.
+function newerModel(model, catalog = []) {
+  const current = modelFamily(model);
+  if (!current) return null;
+  let best = null;
+  for (const candidate of catalog || []) {
+    const family = modelFamily(candidate);
+    if (!family || family.prefix !== current.prefix) continue;
+    if (compareVersions(family.version, current.version) <= 0) continue;
+    const sameTail = family.variant === current.variant;
+    const better = !best
+      || (sameTail && !best.sameTail)
+      || (sameTail === best.sameTail && compareVersions(family.version, best.family.version) > 0);
+    if (better) best = { candidate, family, sameTail };
+  }
+  return best ? best.candidate : null;
+}
+
+// Every model each engine is known to offer, from local files only. Claude,
+// fable, and haiku run through the same CLI, so they share one list.
+function modelCatalog(engines, options = {}) {
+  const catalog = {};
+  const add = (id, models) => {
+    const list = catalog[id] || (catalog[id] = []);
+    for (const model of models || []) if (model && !list.includes(model)) list.push(model);
+  };
+  const rows = availableModels(engines || [], options);
+  for (const row of rows) add(row.engine, row.models);
+  for (const engine of engines || []) add(engine.id, engine.models);
+  const claude = (rows.find((row) => row.engine === 'claude') || {}).models || [];
+  for (const id of CLAUDE_FAMILY) if (catalog[id]) add(id, claude);
+  return catalog;
+}
+
+function localDayText(date) {
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+function wholeDaysSince(dayText, now) {
+  const day = parseRosterUntil(dayText);
+  if (!day) return null;
+  const date = new Date(now);
+  const today = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  return Math.round((today.getTime() - day.getTime()) / DAY_MS);
+}
+
+// The newest proof that this engine and model answer: the line's own
+// "verified" date or the newest landed run on the same engine and model.
+function pinVerified(worker, runs) {
+  let best = worker.verified ? { at: worker.verified, source: 'roster line' } : null;
+  for (const run of runs || []) {
+    if (run.outcome !== 'landed' || run.engine !== worker.engine || !sameModel(run.model, worker.model)) continue;
+    const at = Date.parse(run.at);
+    if (!Number.isFinite(at)) continue;
+    const day = localDayText(new Date(at));
+    if (!best || day > best.at) best = { at: day, source: 'landed run' };
+  }
+  return best;
+}
+
+function quoteArg(text) {
+  const value = String(text || '');
+  return /^[A-Za-z0-9._:/@-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+
+const SCOPE_FLAGS = Object.freeze({ 'all projects': '--everywhere', 'this session': '--session' });
+
+// The assign command that moves a job's first worker to the newer model and
+// keeps everything else on its line: effort, time cap, prep, end date.
+function assignCommand(row, worker, model) {
+  const parts = ['atris engine assign', quoteArg(row.job), worker.engine, '--model', quoteArg(modelLabel(model))];
+  if (worker.effort) parts.push('--effort', worker.effort);
+  if (worker.max_seconds) parts.push('--max', quoteArg(rosterMaxText(worker.max_seconds).replace(/^max /, '')));
+  if (worker.prep) parts.push('--prep', quoteArg(worker.prep));
+  if (worker.until && Number(worker.ends_in_days) > 0) parts.push('--days', String(worker.ends_in_days));
+  if (SCOPE_FLAGS[row.from]) parts.push(SCOPE_FLAGS[row.from]);
+  return parts.join(' ');
+}
+
+function lineHint(file, line, change) {
+  const where = line ? `line ${line} of ${file || 'the roster'}` : (file || 'the roster');
+  return `${change} on ${where}`;
+}
+
+// Mark every worker and job in a roster report with stale_model,
+// newer_model, pin_age_days, and pin_verified_at, and list what needs a
+// look in report.stale. Returns the report.
+function attachStaleModels(report, { catalog = {}, runs = [], now = new Date() } = {}) {
+  const stale = [];
+  const today = localDayText(new Date(now));
+  for (const row of report.jobs || []) {
+    (row.workers || []).forEach((worker, index) => {
+      worker.stale_model = false;
+      worker.newer_model = null;
+      worker.pin_age_days = null;
+      worker.pin_verified_at = null;
+      const view = worker.runs;
+      if (!view || !view.model || !worker.engine || worker.why === 'expired') return;
+      const who = index === 0 ? row.job : `${row.job} backup`;
+      const tool = rosterToolLabel(worker.engine);
+      const newer = newerModel(view.model, catalog[worker.engine]);
+      if (newer) {
+        worker.stale_model = true;
+        worker.newer_model = newer;
+        const from = view.model_source === 'roster' ? '' : ` from ${view.model_source}`;
+        const renew = index === 0
+          ? assignCommand(row, worker, newer)
+          : lineHint(row.file, worker.line, `change the model to ${modelLabel(newer)}`);
+        stale.push({
+          kind: 'newer model',
+          job: row.job,
+          engine: worker.engine,
+          model: view.model,
+          newer_model: newer,
+          from: row.from,
+          file: row.file,
+          line: worker.line,
+          renew,
+          text: `${who}: ${tool} runs ${modelLabel(view.model)}${from}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+        });
+      }
+      if (view.model_source !== 'roster') return;
+      const proof = pinVerified({ ...worker, model: view.model }, runs);
+      if (!proof) return;
+      worker.pin_verified_at = proof.at;
+      worker.pin_age_days = wholeDaysSince(proof.at, now);
+      if (worker.pin_age_days === null || worker.pin_age_days <= PIN_MAX_AGE_DAYS || newer) return;
+      stale.push({
+        kind: 'old pin',
+        job: row.job,
+        engine: worker.engine,
+        model: view.model,
+        pin_verified_at: proof.at,
+        pin_age_days: worker.pin_age_days,
+        from: row.from,
+        file: row.file,
+        line: worker.line,
+        text: `${who}: ${tool} on ${modelLabel(view.model)} was last verified ${worker.pin_age_days} days ago (${proof.source}). smoke one prompt, then ${lineHint(row.file, worker.line, `add "verified ${today}"`)}`,
+      });
+    });
+    // The job's own fields mirror the worker that leads it, else its first.
+    const lead = (row.workers || []).find((worker) => worker.status === 'leads') || (row.workers || [])[0] || {};
+    row.stale_model = Boolean(lead.stale_model);
+    row.newer_model = lead.newer_model || null;
+    row.pin_age_days = lead.pin_age_days === undefined ? null : lead.pin_age_days;
+  }
+  // A member line that pins its own model is checked too; a member that
+  // picks automatically runs its job's worker, already checked above.
+  for (const member of report.team || []) {
+    if (member.source !== 'file' || !member.model || !member.engine) continue;
+    const newer = newerModel(member.model, catalog[member.engine]);
+    member.stale_model = Boolean(newer);
+    member.newer_model = newer;
+    if (!newer) continue;
+    const renew = `change the model to ${modelLabel(newer)} on the ${member.member} line of ${member.file || 'the roster'}`;
+    stale.push({
+      kind: 'newer model',
+      member: member.member,
+      engine: member.engine,
+      model: member.model,
+      newer_model: newer,
+      file: member.file,
+      renew,
+      text: `${member.member}: ${rosterToolLabel(member.engine)} runs ${modelLabel(member.model)}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+    });
+  }
+  report.stale = stale;
+  return report;
+}
+
+module.exports = {
+  PIN_MAX_AGE_DAYS,
+  attachStaleModels,
+  compareVersions,
+  modelCatalog,
+  modelFamily,
+  newerModel,
+};

package/lib/team-lineup.js

@@ -4,7 +4,7 @@
 // come from the same resolver `atris engine roster` uses (jobRosterView and
 // rosterReport in commands/engine.js); this file only picks and words them.
 
-const { engineRunsView, modelLabel } = require('./roster-models');
+const { modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
 const { suggestionCount } = require('./roster-suggest');
 
@@ -75,75 +75,6 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   return `${builtIn.join(' · ')}${marker}`;
 }
 
-function runsText(view) {
-  return view && view.text ? view.text : 'no ready tool';
-}
-
-// "who does each job" lines: the tool and model running each job now, its
-// backup, and a short note when the router or a backup is standing in.
-function renderJobLines(jobs, { width = 80 } = {}) {
-  const rows = orderJobs(jobs);
-  if (!rows.length) return [];
-  const labelWidth = Math.max(...rows.map((row) => row.job.length));
-  return rows.map((row) => {
-    const head = `  ${row.job.padEnd(labelWidth)}  ${runsText(row.now_runs)}`;
-    let note = '';
-    if (!row.pick) note = row.like ? `, same as ${row.like}` : ', picked by the router';
-    else if (row.lead === 'first' && row.backup_runs) note = `, backup ${row.backup_runs.text}`;
-    else if (row.lead !== 'first') note = row.status === 'expired' ? ', first pick expired' : ', first pick not ready';
-    const line = `${head}${note}`;
-    return line.length <= width || row.lead !== 'first' ? line : head;
-  });
-}
-
-// Names under each job, wrapped to the width. A member running something
-// other than its job's tool and model says what it runs.
-function renderMemberLines(team, jobs, { width = 80 } = {}) {
-  const members = Array.isArray(team) ? team : [];
-  if (!members.length) return [];
-  const rows = orderJobs(jobs);
-  const order = [...rows.map((row) => row.job)];
-  for (const member of members) if (member.job && !order.includes(member.job)) order.push(member.job);
-  const groups = order
-    .map((job) => ({ job, row: rows.find((row) => row.job === job) || null, names: members.filter((member) => member.job === job) }))
-    .filter((group) => group.names.length);
-  const labelWidth = Math.max(...groups.map((group) => group.job.length));
-  const indent = ' '.repeat(labelWidth + 4);
-  const lines = [];
-  for (const group of groups) {
-    const jobText = group.row && group.row.now_runs ? group.row.now_runs.text : '';
-    const names = group.names.map((member) => {
-      const text = member.engine ? engineRunsView(member.engine, { model: member.model || '', effort: member.effort || '' }).text : 'no ready tool';
-      return text === jobText ? member.member : `${member.member} on ${text}`;
-    });
-    let line = `  ${group.job.padEnd(labelWidth)}  `;
-    let fresh = true;
-    for (const name of names) {
-      const piece = fresh ? name : `, ${name}`;
-      if (!fresh && line.length + piece.length + 1 > width) {
-        lines.push(`${line},`);
-        line = `${indent}${name}`;
-      } else {
-        line += piece;
-      }
-      fresh = false;
-    }
-    lines.push(line);
-  }
-  return lines;
-}
-
-// The block `atris team` prints before today's active and rest lists.
-function renderLineup(lineup, { width = 80 } = {}) {
-  if (!lineup || !lineup.ok) return '';
-  const jobLines = renderJobLines(lineup.jobs, { width });
-  const memberLines = renderMemberLines(lineup.team, lineup.jobs, { width });
-  const blocks = [];
-  if (jobLines.length) blocks.push(['who does each job:', ...jobLines].join('\n'));
-  if (memberLines.length) blocks.push(['who is on each job:', ...memberLines].join('\n'));
-  return blocks.join('\n\n');
-}
-
 // Per member, for json: the job, tool, model, and whether a roster line or
 // the automatic match decided it. null for a name the lineup does not know.
 function memberLineup(lineup, name) {
@@ -161,12 +92,20 @@ function memberLineup(lineup, name) {
   };
 }
 
+// The two commands under both team tables: the real way to change a job's
+// worker (assign takes a job, not a member) and the real way to start a
+// member working (it runs on the member's roster engine).
+const TEAM_FOOTER = Object.freeze([
+  'change who does a job: atris engine assign <job> <tool> --model <model>',
+  'launch a member: atris member run <member> "<goal>" --minutes 30',
+]);
+
 const LINEUP_UNREADABLE = 'could not read who does each job, so tools and models are not shown. try: atris engine roster';
 
 module.exports = {
   LINEUP_UNREADABLE,
+  TEAM_FOOTER,
   bootTeamLine,
   memberLineup,
   readLineupSafe,
-  renderLineup,
 };

package/lib/team-presence.js

@@ -262,10 +262,234 @@ function renderTeamPresence(presence) {
   return lines.join('\n');
 }
 
+// --- who really worked this week ------------------------------------------
+//
+// "Awake" above is a 15-minute window. A member that did real work yesterday
+// is not awake, but it is active. Activity reads evidence that already sits
+// on disk: dated files in atris/team/<member>/logs/, commits that name the
+// member, runs the roster recorded for the member, and the same stream
+// events presence reads (task claims, mission receipts, worktree commits),
+// over a wider window. Each piece of evidence counts as one run on its day.
+// A member with evidence in the last 7 days is active; 8 to 14 days is
+// quiet; nothing in 14 days is idle.
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const ACTIVE_DAYS = 7;
+const IDLE_AFTER_DAYS = 14;
+const FAILED_RUN_OUTCOMES = new Set(['failed', 'stalled', 'credit out']);
+
+function localDay(ms) {
+  const date = new Date(ms);
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+// The first real YYYY-MM-DD in a log file name, as a local day ('' if none).
+function logFileDay(name) {
+  const match = /(\d{4})-(\d{2})-(\d{2})/.exec(String(name || ''));
+  if (!match) return '';
+  const [year, month, day] = match.slice(1).map(Number);
+  const date = new Date(year, month - 1, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) return '';
+  return match[0];
+}
+
+// `git log --format=%x1e%aI%x1f%B` output, read once for the whole team.
+function parseGitLog(text) {
+  return String(text || '').split('\x1e').map((chunk) => {
+    const [at, ...rest] = chunk.split('\x1f');
+    const message = rest.join('\x1f').trim();
+    const ms = timestampMs(String(at || '').trim());
+    if (!ms || !message) return null;
+    const [subject, ...body] = message.split(/\r?\n/);
+    return { ms, subject: subject.trim(), body: body.join('\n') };
+  }).filter(Boolean);
+}
+
+// Which members a commit names, and whether it is a revert. Plain words are
+// not enough: member names like "notes", "sites", and "builder" also show up
+// in ordinary messages and in the atris-builder co-author line. A commit
+// names a member through a "Member: <name>" or "Atris-Member: <name>"
+// trailer, a co-author whose display name is the member, or a subject that
+// starts with "<name>:" or "<name>(scope):". A revert names whoever the
+// reverted subject named.
+function commitMembers(commit, known) {
+  const names = new Set();
+  const check = (value) => {
+    const key = String(value || '').trim().toLowerCase();
+    if (key && known.has(key)) names.add(key);
+  };
+  let subject = String(commit.subject || '');
+  const revert = /^revert\s+"(.+)"\s*$/i.exec(subject);
+  if (revert) subject = revert[1];
+  const prefix = /^([a-z0-9][a-z0-9_.-]*)(?:\([^)]*\))?:\s/i.exec(subject);
+  if (prefix) check(prefix[1]);
+  for (const line of String(commit.body || '').split(/\r?\n/)) {
+    const trailer = /^\s*(?:atris-)?member:\s*([a-z0-9_.-]+)\s*$/i.exec(line);
+    if (trailer) check(trailer[1]);
+    const coauthor = /^\s*co-authored-by:\s*([^<]+?)\s*</i.exec(line);
+    if (coauthor) check(coauthor[1]);
+  }
+  return { names: [...names], reverted: Boolean(revert) };
+}
+
+function emptyDay() {
+  return { runs: 0, landed: 0, failed: 0, reverted: 0, engines: {}, models: {} };
+}
+
+function topKey(counts) {
+  let best = '';
+  for (const [key, count] of Object.entries(counts || {})) {
+    if (!best || count > counts[best]) best = key;
+  }
+  return best || null;
+}
+
+// The busiest engine and the busiest model among that engine's own runs, so
+// the pair always names something that actually ran together.
+function enginePair(engines, models) {
+  const engine = topKey(engines);
+  const own = Object.fromEntries(Object.entries(models || {}).filter(([key]) => !engine || key.startsWith(`${engine}\u0000`)));
+  const modelKey = topKey(own);
+  return { engine, model: modelKey ? modelKey.split('\u0000')[1] : null };
+}
+
+// One activity row per member, from evidence gathered by the caller:
+//   logDays: { member: ['2026-09-28', ...] }
+//   commits: parsed git log rows ({ ms, subject, body })
+//   runs:    roster run records ({ at, member, engine, model, outcome })
+//   events:  stream events ({ agent, ms | ts, summary })
+function buildMemberActivity(input = {}) {
+  const nowMs = timestampMs(input.nowMs ?? input.now ?? Date.now()) || Date.now();
+  const names = [...new Set((input.members || []).map((name) => String(name || '').trim().toLowerCase()).filter(Boolean))];
+  const known = new Set(names);
+  const today = localDay(nowMs);
+  const activeSince = localDay(nowMs - (ACTIVE_DAYS - 1) * DAY_MS);
+  const quietSince = localDay(nowMs - (IDLE_AFTER_DAYS - 1) * DAY_MS);
+  const byMember = new Map(names.map((name) => [name, { days: {}, last: '', evidence: { logs: 0, commits: 0, runs: 0, events: 0 } }]));
+  const note = (member, day, source, apply) => {
+    const row = byMember.get(member);
+    if (!row || !day || day > today) return;
+    if (day > row.last) row.last = day;
+    if (day < quietSince) return;
+    const bucket = row.days[day] || (row.days[day] = emptyDay());
+    bucket.runs += 1;
+    row.evidence[source] += 1;
+    if (apply) apply(bucket);
+  };
+
+  for (const [member, days] of Object.entries(input.logDays || {})) {
+    for (const day of days || []) note(String(member).toLowerCase(), logFileDay(day), 'logs');
+  }
+  for (const commit of input.commits || []) {
+    const { names: named, reverted } = commitMembers(commit, known);
+    for (const member of named) {
+      note(member, localDay(commit.ms), 'commits', (bucket) => {
+        if (reverted) bucket.reverted += 1;
+        else bucket.landed += 1;
+      });
+    }
+  }
+  for (const run of input.runs || []) {
+    const member = String(run.member || '').trim().toLowerCase();
+    const ms = timestampMs(run.at);
+    if (!member || !ms) continue;
+    note(member, localDay(ms), 'runs', (bucket) => {
+      if (run.outcome === 'landed') bucket.landed += 1;
+      else if (FAILED_RUN_OUTCOMES.has(run.outcome)) bucket.failed += 1;
+      if (run.engine) bucket.engines[run.engine] = (bucket.engines[run.engine] || 0) + 1;
+      if (run.model) bucket.models[`${run.engine || ''}\u0000${run.model}`] = (bucket.models[`${run.engine || ''}\u0000${run.model}`] || 0) + 1;
+    });
+  }
+  // A task or mission shows up as several stream events; one per summary
+  // per day counts.
+  const seenEvents = new Set();
+  for (const event of input.events || []) {
+    const member = memberName(event?.agent || event?.member || event?.owner).toLowerCase();
+    const ms = timestampMs(event?.ms || event?.ts || event?.at || event?.created_at);
+    if (!member || !ms || !known.has(member)) continue;
+    const day = localDay(ms);
+    const key = `${member}|${day}|${event.summary || event.event || ''}`;
+    if (seenEvents.has(key)) continue;
+    seenEvents.add(key);
+    note(member, day, 'events');
+  }
+
+  return names.map((name) => {
+    const row = byMember.get(name);
+    const week = Object.entries(row.days).filter(([day]) => day >= activeSince);
+    const sum = (field) => week.reduce((total, [, bucket]) => total + bucket[field], 0);
+    const engines = {};
+    const models = {};
+    for (const [, bucket] of week) {
+      for (const [key, count] of Object.entries(bucket.engines)) engines[key] = (engines[key] || 0) + count;
+      for (const [key, count] of Object.entries(bucket.models)) models[key] = (models[key] || 0) + count;
+    }
+    const { engine, model } = enginePair(engines, models);
+    const lastMs = row.last ? new Date(`${row.last}T12:00:00`).getTime() : 0;
+    const status = row.last >= activeSince ? 'active' : row.last >= quietSince ? 'quiet' : 'idle';
+    return {
+      name,
+      status,
+      last_active: row.last || null,
+      days_since: row.last ? Math.max(0, Math.round((new Date(`${today}T12:00:00`).getTime() - lastMs) / DAY_MS)) : null,
+      runs_7d: sum('runs'),
+      engine,
+      model,
+      landed: sum('landed'),
+      failed: sum('failed'),
+      reverted: sum('reverted'),
+      evidence: row.evidence,
+      days: Object.fromEntries(Object.entries(row.days).sort(([a], [b]) => a.localeCompare(b)).map(([day, bucket]) => [day, {
+        runs: bucket.runs,
+        ...enginePair(bucket.engines, bucket.models),
+        landed: bucket.landed,
+        failed: bucket.failed,
+        reverted: bucket.reverted,
+      }])),
+    };
+  });
+}
+
+// The first local day of the 7-day activity window.
+function activeWindowStartDay(nowMs = Date.now()) {
+  return localDay((timestampMs(nowMs) || Date.now()) - (ACTIVE_DAYS - 1) * DAY_MS);
+}
+
+// One row per member per day with any evidence in the last 7 days, the
+// shape the self-improvement loop reads from member_activity.jsonl.
+function memberActivityRows(activity, nowMs = Date.now()) {
+  const since = activeWindowStartDay(nowMs);
+  const rows = [];
+  for (const member of activity || []) {
+    for (const [day, bucket] of Object.entries(member.days || {})) {
+      if (day < since || !bucket.runs) continue;
+      rows.push({
+        member: member.name,
+        day,
+        runs: bucket.runs,
+        engine: bucket.engine,
+        model: bucket.model,
+        landed: bucket.landed,
+        failed: bucket.failed,
+        reverted: bucket.reverted,
+      });
+    }
+  }
+  return rows.sort((a, b) => a.day.localeCompare(b.day) || a.member.localeCompare(b.member));
+}
+
 module.exports = {
   ACTIVE_MISSION_STATES,
   ACTIVE_TASK_STATES,
   DEFAULT_FRESHNESS_WINDOW_MS,
+  IDLE_AFTER_DAYS,
+  activeWindowStartDay,
+  buildMemberActivity,
   buildTeamPresence,
+  commitMembers,
+  logFileDay,
+  memberActivityRows,
+  parseGitLog,
   renderTeamPresence,
 };

package/lib/text-table.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Plain aligned tables for terminal views: a header row, two spaces between
+// columns, no borders or pipes. A cell may hold several lines; the extra
+// lines sit under the first, in the same column. When the table is wider
+// than the terminal, columns marked `clip` or `wrap` shrink (rightmost
+// first): a clip column ends in "…", a wrap column carries on underneath.
+// Every other column keeps its full width.
+
+const GAP = '  ';
+const ELLIPSIS = '…';
+const FALLBACK_WIDTH = 100;
+
+function terminalWidth(width) {
+  const value = Number(width || process.stdout.columns);
+  return Number.isFinite(value) && value >= 20 ? value : FALLBACK_WIDTH;
+}
+
+function clipText(text, width) {
+  const value = String(text);
+  if (value.length <= width) return value;
+  if (width <= 1) return ELLIPSIS.slice(0, Math.max(0, width));
+  return `${value.slice(0, width - 1).trimEnd()}${ELLIPSIS}`;
+}
+
+// Word-wrap one line to a width; a word longer than the width is split.
+function wrapText(text, width) {
+  const out = [];
+  let line = '';
+  for (let word of String(text).split(' ')) {
+    while (word.length > width) {
+      if (line) { out.push(line); line = ''; }
+      out.push(word.slice(0, width));
+      word = word.slice(width);
+    }
+    const next = line ? `${line} ${word}` : word;
+    if (next.length > width && line) { out.push(line); line = word; } else line = next;
+  }
+  out.push(line);
+  return out;
+}
+
+function cellLines(value) {
+  if (Array.isArray(value)) {
+    const lines = value.filter((line) => line !== null && line !== undefined).map(String);
+    return lines.length ? lines : [''];
+  }
+  return [value === null || value === undefined ? '' : String(value)];
+}
+
+// columns: [{ header, clip?, min? }]; rows: arrays of cells, one per column.
+// Returns the table as one string, each line trimmed at the end.
+function renderTable(columns, rows, { width } = {}) {
+  const max = terminalWidth(width);
+  const cells = rows.map((row) => columns.map((_, index) => cellLines(row[index])));
+  const widths = columns.map((column, index) => Math.max(
+    String(column.header).length,
+    ...cells.map((row) => Math.max(...row[index].map((line) => line.length))),
+  ));
+  let over = widths.reduce((sum, value) => sum + value, 0) + GAP.length * (columns.length - 1) - max;
+  for (let index = columns.length - 1; index >= 0 && over > 0; index -= 1) {
+    if (!columns[index].clip && !columns[index].wrap) continue;
+    const floor = Math.max(String(columns[index].header).length, columns[index].min || 8);
+    const cut = Math.min(over, Math.max(0, widths[index] - floor));
+    widths[index] -= cut;
+    over -= cut;
+  }
+  const line = (parts) => parts
+    .map((text, index) => clipText(text, widths[index]).padEnd(index === parts.length - 1 ? 0 : widths[index]))
+    .join(GAP)
+    .trimEnd();
+  const out = [line(columns.map((column) => column.header))];
+  for (const raw of cells) {
+    const row = raw.map((lines, index) => (columns[index].wrap ? lines.flatMap((text) => wrapText(text, widths[index])) : lines));
+    const height = Math.max(...row.map((lines) => lines.length));
+    for (let at = 0; at < height; at += 1) out.push(line(row.map((lines) => lines[at] || '')));
+  }
+  return out.join('\n');
+}
+
+module.exports = { FALLBACK_WIDTH, clipText, renderTable, terminalWidth };

package/package.json

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