atris 3.63.0 → 3.65.0

package/commands/engine.js

@@ -35,9 +35,12 @@ const {
 const { parseScopeFlag } = require('../lib/cli-scope');
 const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
 const { teamRosterView } = require('../lib/member-engine');
-const { engineRunsView, availableModels } = require('../lib/roster-models');
+const { engineModelText, engineRunsView, availableModels, modelLabel } = require('../lib/roster-models');
+const { renderTable } = require('../lib/text-table');
+const { TEAM_FOOTER } = require('../lib/team-lineup');
 const { readRosterRuns, workerRuns, summarizeRuns, recentRuns, renderRunLine, DEFAULT_DAYS: RUN_DAYS } = require('../lib/roster-runs');
 const { attachSuggestions } = require('../lib/roster-suggest');
+const { PIN_MAX_AGE_DAYS: PIN_STALE_DAYS, attachStaleModels, modelCatalog } = require('../lib/roster-stale');
 const {
   ENGINE_ROLES,
   ENGINE_JOBS,
@@ -69,6 +72,8 @@ const {
   readEngineRegistry,
   resolveEngineForRole,
   resolveEngineForRoleRanked,
+  resolveNotesJob,
+  jobTakesAnyEngine,
   requireEngineBin,
   engineDoctorReport,
   engineFailureHealthStatus,
@@ -1000,10 +1005,41 @@ function rosterPickEntry(value) {
 
 const WORKER_SKIP_WORDS = Object.freeze({ 'not ready': 'down', expired: 'expired', 'bad model': 'names a model it cannot run' });
 
+// A worker whose end date is this many days away or fewer gets a heads-up.
+const ENDS_SOON_DAYS = 7;
+const RENEW_COMMAND = 'atris engine roster confirm';
+
+// Whole local days from today to a worker's end date: 0 on its last day,
+// negative once it has ended, null when it has no valid end date.
+function endsInDays(until, now = new Date()) {
+  const end = parseRosterUntil(until);
+  if (!end) return null;
+  const date = new Date(now);
+  if (Number.isNaN(date.getTime())) return null;
+  const today = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  return Math.round((end.getTime() - today.getTime()) / 86400000);
+}
+
+function endsSoon(days) {
+  return days !== null && days >= 0 && days <= ENDS_SOON_DAYS;
+}
+
+function endsInText(days) {
+  if (days === 0) return 'ends today';
+  if (days === 1) return 'ends tomorrow';
+  return `ends in ${days} days`;
+}
+
+function shortDay(until) {
+  const date = parseRosterUntil(until);
+  return date ? date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }).toLowerCase() : '';
+}
+
 // One worker of a job's team as the view shows it: what it runs, and whether
 // it leads now, backs up, or is skipped and why.
-function workerRow(step, index, leadIndex) {
+function workerRow(step, index, leadIndex, now = new Date()) {
   const { worker } = step;
+  const endsIn = endsInDays(worker.until, now);
   const runs = worker.error ? null : engineRunsView(worker.engine, { model: worker.model || '', effort: worker.effort || '' });
   const status = index === leadIndex ? 'leads' : step.skip ? 'skipped' : 'backup';
   const why = step.skip === 'bad line' ? `bad line: ${worker.error}`
@@ -1016,6 +1052,9 @@ function workerRow(step, index, leadIndex) {
     max_seconds: Number(worker.max_seconds) > 0 ? Number(worker.max_seconds) : null,
     prep: worker.prep ? rosterJobLabel(worker.prep) : null,
     until: worker.until || null,
+    ends_in_days: endsIn,
+    expiring_soon: endsSoon(endsIn),
+    verified: worker.verified || null,
     line: worker.line || null,
     ...(worker.error ? { text: worker.text || '' } : {}),
     status,
@@ -1041,7 +1080,7 @@ function jobRosterRow(job, role, root, state, registry, now, key = role) {
   const decided = rosterDecided(resolved.source) && (!custom || resolved.job === job);
   const source = decided ? resolved.source : ROSTER_LAYERS.find((scope) => picks[scope]) || null;
   const pick = source ? picks[source] : null;
-  const walk = pick ? rosterWorkerWalk(pick, role, registry, now) : [];
+  const walk = pick ? rosterWorkerWalk(pick, role, registry, now, { anyEngine: jobTakesAnyEngine(key) }) : [];
   const leadIndex = decided && resolved.source === source ? walk.findIndex((step) => !step.skip) : -1;
   const good = walk.map((step, index) => ({ step, index })).filter(({ step }) => !step.worker.error);
   const first = good[0] || null;
@@ -1055,6 +1094,7 @@ function jobRosterRow(job, role, root, state, registry, now, key = role) {
       : good[1] && leadIndex === good[1].index ? 'backup'
         : 'later';
   const kind = Object.keys(ENGINE_JOBS).find((name) => ENGINE_JOBS[name] === role);
+  const pickEndsIn = pick ? endsInDays(pick.until, now) : null;
   // What the job really runs: its first two good workers, each with its own
   // model and effort, or the router's engine when no line decides.
   const runsOf = (entry) => (entry ? engineRunsView(entry.step.worker.engine, { model: entry.step.worker.model || '', effort: entry.step.worker.effort || '' }) : null);
@@ -1076,12 +1116,14 @@ function jobRosterRow(job, role, root, state, registry, now, key = role) {
     model: resolved.engine && resolved.engine.roster_model ? resolved.engine.roster_model : null,
     effort: resolved.engine && resolved.engine.roster_effort ? resolved.engine.roster_effort : null,
     max_seconds: pick && Number(pick.max_seconds) > 0 ? Number(pick.max_seconds) : null,
+    ends_in_days: pickEndsIn,
+    expiring_soon: endsSoon(pickEndsIn),
     prep: first && first.step.worker.prep ? rosterJobLabel(first.step.worker.prep) : null,
     backup_prep: good[1] && good[1].step.worker.prep ? rosterJobLabel(good[1].step.worker.prep) : null,
     runs: runs || nowRuns,
     backup_runs: runsOf(good[1]),
     now_runs: nowRuns,
-    workers: walk.map((step, index) => workerRow(step, index, leadIndex)),
+    workers: walk.map((step, index) => workerRow(step, index, leadIndex, now)),
     lead,
     status,
     ...(status === 'cooling' ? { cooling: first.step.cooling.text } : {}),
@@ -1114,8 +1156,11 @@ function rosterReport(root = process.cwd(), now = new Date()) {
   const state = readRosterState(root, { now });
   const jobs = jobRosterView(root, now, state);
   const team = teamRosterView(root, { now, rosterState: state });
+  const expiring = expiringWorkers(jobs);
   return {
     jobs,
+    expiring,
+    renew_command: expiring.length ? RENEW_COMMAND : null,
     team: team.rows,
     warnings: [...state.session.warnings, ...state.project.warnings, ...state.machine.warnings, ...team.warnings],
     files: {
@@ -1127,75 +1172,203 @@ function rosterReport(root = process.cwd(), now = new Date()) {
   };
 }
 
-function untilText(worker) {
+// Every worker, in any job, whose end date is today or within the next
+// seven days. Workers already past their date show on their own lines. A
+// job set for this shell only is skipped: roster confirm does not renew it.
+function expiringWorkers(jobs) {
+  const list = [];
+  for (const row of jobs || []) {
+    if (row.session_pick) continue;
+    for (const worker of row.workers || []) {
+      if (!worker.expiring_soon) continue;
+      list.push({
+        job: row.job,
+        engine: worker.engine,
+        model: worker.model,
+        tool: worker.runs ? worker.runs.text : worker.engine,
+        until: worker.until,
+        ends_in_days: worker.ends_in_days,
+        from: row.from,
+      });
+    }
+  }
+  return list;
+}
+
+function untilText(worker, days = null) {
   const until = parseRosterUntil(worker.until);
-  if (until) return `until ${until.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }).toLowerCase()}`;
+  if (until) return `until ${shortDay(worker.until)}${endsSoon(days) ? `, ${endsInText(days)}` : ''}`;
   return worker.never_expires ? 'no end date' : 'until no valid date';
 }
 
-// Every worker under its job, numbered in order, when the job has more than
-// the lead and one backup (the job's own line already shows those two).
-function renderWorkerLines(row) {
-  if (!row.workers || row.workers.length <= 2) return [];
-  const width = Math.max(...row.workers.map((worker) => (worker.runs ? worker.runs.text : worker.text || '').length));
-  return row.workers.map((worker, index) => {
-    const what = (worker.runs ? worker.runs.text : worker.text || '').padEnd(width);
-    const extras = [worker.max_seconds ? rosterMaxText(worker.max_seconds) : '', worker.prep ? `prepped by ${worker.prep}` : '', worker.until ? `until ${worker.until}` : ''].filter(Boolean);
-    const state = worker.status === 'leads' ? 'leads now' : worker.status === 'backup' ? 'backup' : `skipped, ${worker.why}`;
-    return `  ${index + 1}. ${what} ${[state, ...extras].join(', ')}`.trimEnd();
-  });
+// One line under the jobs when any worker ends within seven days, naming
+// each one and the command that keeps it going.
+function renderExpiringLine(expiring) {
+  if (!expiring || !expiring.length) return '';
+  const names = expiring.map((item) => `${item.tool} on ${item.job} ${endsInText(item.ends_in_days)}`);
+  const them = expiring.length === 1 ? 'it' : 'them';
+  return `heads up: ${names.join(', ')}. to keep ${them} 30 more days, run: ${RENEW_COMMAND}`;
 }
 
-// Each worker's recent record under its job, only for workers with runs.
-function renderWorkerRecords(row) {
-  return (row.workers || [])
-    .filter((worker) => worker.record)
-    .map((worker) => `  ${worker.runs ? worker.runs.text : worker.engine}: ${worker.record.text}`);
-}
-
-function renderJobRoster(rows) {
-  const width = Math.max(7, ...rows.map((row) => row.job.length));
-  const ownerWidth = Math.max(24, ...rows.filter((row) => row.pick && row.runs).map((row) => row.runs.text.length));
-  const backupWidth = Math.max(16, ...rows.filter((row) => row.backup_runs).map((row) => row.backup_runs.text.length + 7));
-  return rows.map((row) => {
-    const label = row.job.padEnd(width);
-    const nowText = row.now_runs ? row.now_runs.text : 'no ready engine';
-    const fallsTo = `${row.like ? `falls back to ${row.like}` : 'router decides'}: ${nowText}`;
-    if (!row.pick) return `${label} no pick, ${fallsTo}`;
-    const owner = row.runs.text.padEnd(ownerWidth);
-    const backup = row.backup_runs ? `backup ${row.backup_runs.text}${row.backup_prep ? ` prepped by ${row.backup_prep}` : ''}` : 'no backup';
-    const cap = `${row.max_seconds ? `${rosterMaxText(row.max_seconds)}, ` : ''}${row.prep ? `prepped by ${row.prep}, ` : ''}`;
-    const date = untilText(row.pick);
-    const fallback = row.lead === 'backup' ? 'using backup' : row.lead === 'later' ? `using ${nowText}` : fallsTo;
-    const status = row.status === 'expired' ? `expired, ${fallback}`
-      : row.status === 'cooling' ? `${row.cooling}, ${fallback}`
-        : row.status === 'not ready' ? `not ready, ${fallback}`
-          : date;
-    const where = row.file ? `${row.from} (${row.file})` : row.from;
-    const head = `${label} ${owner} ${backup.padEnd(backupWidth)} ${cap}${status}, ${where}`.trimEnd();
-    const suggestion = row.suggestion ? [`  suggestion: ${row.suggestion.text}`] : [];
-    return [head, ...renderWorkerLines(row), ...renderWorkerRecords(row), ...suggestion].join('\n');
-  }).join('\n');
+// The same heads-up, short enough for one boot line.
+function bootExpiringLine(expiring) {
+  if (!expiring || !expiring.length) return '';
+  const [first] = expiring;
+  const more = expiring.length > 1 ? ` and ${expiring.length - 1} more` : '';
+  return `${first.tool} on ${first.job} ${endsInText(first.ends_in_days)}${more}. renew: ${RENEW_COMMAND}`;
+}
+
+// --- the roster as tables -------------------------------------------------
+//
+// One row per job, one row per member. Plain columns, a header row, two
+// spaces between; a cell that needs more than one line (effort, several
+// backups) carries on underneath in its own column.
+
+function workerCellText(view) {
+  return view ? engineModelText(view.engine, view.model) : '';
+}
+
+function maxCellText(seconds) {
+  const text = rosterMaxText(seconds);
+  return text ? text.replace(/^max /, '') : '-';
+}
+
+// Workers that name a tool the roster can run, in written order.
+function goodWorkers(row) {
+  return (row.workers || []).filter((worker) => worker.engine && worker.runs);
+}
+
+// Why a backup is passed over, in two or three words.
+function backupSkipText(worker) {
+  if (worker.status !== 'skipped') return '';
+  if (worker.why === 'expired' && worker.ends_in_days !== null && worker.ends_in_days !== undefined) return `ended ${shortDay(worker.until)}`;
+  return worker.why || 'skipped';
+}
+
+// "newer <model> out" or "pin 45 days old": the outdated-model flags,
+// short enough for the note column. The full line with its fix prints
+// under the table.
+function staleNote(worker) {
+  if (worker.stale_model && worker.newer_model) return `newer ${modelLabel(worker.newer_model)} out`;
+  if (worker.pin_age_days !== null && worker.pin_age_days !== undefined && worker.pin_age_days > PIN_STALE_DAYS) return `pin ${worker.pin_age_days} days old`;
+  return '';
+}
+
+function jobNoteText(row, lead, backups, mainFrom) {
+  // A tool on its own default model is named alone here, to keep notes short.
+  const nowText = !row.now_runs ? 'no ready engine' : row.now_runs.model ? workerCellText(row.now_runs) : row.now_runs.engine;
+  if (!row.pick) return row.like ? `no pick, same as ${row.like}` : 'no pick, router decides';
+  const fallback = row.lead === 'backup' ? 'using backup'
+    : row.lead === 'later' ? `using ${nowText}`
+      : row.like ? `falls back to ${row.like}` : `router decides: ${nowText}`;
+  const ended = row.ends_in_days !== null && row.ends_in_days !== undefined ? `ended ${shortDay(row.pick.until)}` : 'expired';
+  const parts = [];
+  if (row.status === 'expired') parts.push(`${ended}, ${fallback}`);
+  else if (row.status === 'cooling') parts.push(`${row.cooling}, ${fallback}`);
+  else if (row.status === 'not ready') parts.push(`not ready, ${fallback}`);
+  else if (row.expiring_soon) parts.push(endsInText(row.ends_in_days));
+  if (lead && lead.prep) parts.push(`prep: ${lead.prep}`);
+  if (lead && staleNote(lead)) parts.push(staleNote(lead));
+  for (const worker of backups) if (staleNote(worker)) parts.push(`backup ${staleNote(worker)}`);
+  if (row.from && row.from !== mainFrom) parts.push(`from ${row.from}`);
+  return parts.join(', ');
+}
+
+// The roster file most jobs come from; the table heading names it.
+function mainRosterSource(rows) {
+  const counts = new Map();
+  for (const row of rows) if (row.pick && row.from) counts.set(row.from, (counts.get(row.from) || 0) + 1);
+  const [from] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0] || [];
+  const row = rows.find((item) => item.from === from);
+  return { from: from || null, file: row ? row.file : null };
+}
+
+function jobTableRow(row, mainFrom) {
+  const [lead, ...backups] = row.pick ? goodWorkers(row) : [];
+  const leadView = row.pick ? (lead && lead.runs) : row.now_runs;
+  const leads = leadView
+    ? [workerCellText(leadView), leadView.effort ? `(${leadView.effort} effort)` : null]
+    : [row.pick ? 'no ready tool' : 'no ready engine'];
+  const backupCell = backups.length
+    ? backups.map((worker) => {
+      // Effort, max time, and prep for a backup stay in --json; the cell keeps
+      // what changes who runs: a skip reason or an end date.
+      const skip = backupSkipText(worker);
+      const until = !skip && parseRosterUntil(worker.until) ? `until ${shortDay(worker.until)}${worker.expiring_soon ? `, ${endsInText(worker.ends_in_days)}` : ''}` : '';
+      const extras = [skip, until].filter(Boolean);
+      return `${workerCellText(worker.runs)}${extras.length ? ` (${extras.join(', ')})` : ''}`;
+    })
+    : ['none'];
+  const until = lead && parseRosterUntil(lead.until) ? lead.until : '-';
+  return [
+    row.job,
+    leads,
+    backupCell,
+    lead ? maxCellText(lead.max_seconds) : '-',
+    until,
+    jobNoteText(row, lead, backups, mainFrom) || '-',
+  ];
 }
 
-function renderTeamRoster(rows) {
+function renderJobRoster(rows, { width, heading = true } = {}) {
   if (!rows.length) return '';
-  const width = Math.max(6, ...rows.map((row) => row.member.length));
-  const jobWidth = Math.max(6, ...rows.map((row) => String(row.job || '').length));
-  const lines = rows.map((row) => {
-    const engine = row.engine ? engineRunsView(row.engine, { model: row.model || '', effort: row.effort || '' }).text : 'no ready engine';
-    const how = row.source === 'file' ? `from ${row.file}` : 'automatic';
-    return `${row.member.padEnd(width)} ${String(row.job || '').padEnd(jobWidth)} ${engine.padEnd(24)} ${how}`.trimEnd();
+  const { from, file } = mainRosterSource(rows);
+  const columns = [
+    { header: 'JOB' }, { header: 'LEADS' }, { header: 'BACKUP' }, { header: 'MAX' }, { header: 'UNTIL' },
+    { header: 'NOTE', wrap: true, min: 16 },
+  ];
+  const table = renderTable(columns, rows.map((row) => jobTableRow(row, from)), { width });
+  const title = !heading ? '' : file ? `jobs, from ${file}` : 'jobs';
+  const suggestions = rows.filter((row) => row.suggestion).map((row) => `suggestion for ${row.job}: ${row.suggestion.text}`);
+  return [title, table, ...renderWorkerRecords(rows, { width }), ...suggestions].filter(Boolean).join('\n');
+}
+
+// Each worker's recent record (last 7 days), only for workers with runs, as
+// one small table under the jobs.
+function renderWorkerRecords(rows, { width } = {}) {
+  const records = [];
+  for (const row of rows) {
+    for (const worker of row.workers || []) {
+      if (worker.record) records.push([row.job, worker.runs ? workerCellText(worker.runs) : worker.engine, worker.record.text.replace(/^last \d+ days: /, '')]);
+    }
+  }
+  if (!records.length) return [];
+  return ['\nlast 7 days', renderTable([{ header: 'JOB' }, { header: 'WORKER' }, { header: 'RECORD', clip: true, min: 20 }], records, { width })];
+}
+
+// "sep 30, 3 runs" or "quiet 8 to 14 days", from the same evidence atris
+// team reads. '-' for idle members and when activity was not read.
+function teamActivityTag(activity) {
+  if (!activity || activity.status === 'idle') return '-';
+  if (activity.status === 'quiet') return 'quiet 8 to 14 days';
+  const runs = Number(activity.runs_7d) || 0;
+  const day = activity.days_since === 0 ? 'today' : activity.days_since === 1 ? 'yesterday' : shortDay(activity.last_active);
+  return `${day}, ${runs} run${runs === 1 ? '' : 's'}`;
+}
+
+function renderTeamRoster(rows, { width } = {}) {
+  if (!rows.length) return '';
+  const showActivity = rows.some((row) => row.activity !== undefined);
+  const columns = [{ header: 'MEMBER' }, { header: 'JOB' }, { header: 'ENGINE · MODEL' }, { header: 'SOURCE' }];
+  if (showActivity) columns.push({ header: 'LAST 7 DAYS', clip: true, min: 11 });
+  const cells = rows.map((row) => {
+    const engine = row.engine ? workerCellText(engineRunsView(row.engine, { model: row.model || '', effort: row.effort || '' })) : 'no ready engine';
+    const stale = row.stale_model && row.newer_model ? ` (newer ${modelLabel(row.newer_model)} out)` : '';
+    const cell = [row.member, row.job || '-', `${engine}${stale}`, row.source === 'file' ? (row.file || 'roster file') : 'automatic'];
+    if (showActivity) cell.push(teamActivityTag(row.activity));
+    return cell;
   });
-  return ['team', ...lines].join('\n');
+  return ['team', renderTable(columns, cells, { width })].join('\n');
 }
 
 function renderRosterWarnings(warnings) {
   return warnings.map((warning) => `warning: ${warning.file} line ${warning.line} "${warning.text}" ${warning.message}.`).join('\n');
 }
 
-function renderRosterReport(report) {
-  return [renderJobRoster(report.jobs), renderTeamRoster(report.team), renderRosterWarnings(report.warnings)]
+function renderRosterReport(report, { width } = {}) {
+  const stale = (report.stale || []).map((item) => item.text);
+  const jobs = [renderJobRoster(report.jobs, { width }), renderExpiringLine(report.expiring), ...stale].filter(Boolean).join('\n');
+  return [jobs, renderTeamRoster(report.team, { width }), renderRosterWarnings(report.warnings)]
     .filter(Boolean)
     .join('\n\n');
 }
@@ -1204,8 +1377,6 @@ function printJobRoster(root, now = new Date()) {
   console.log(renderRosterReport(rosterReport(root, now)));
 }
 
-const AVAILABLE_HINT = 'see which tools and models this machine has: atris engine roster --available';
-
 // Each installed tool and the models it offers, from local files only.
 function availableReport(root) {
   const engines = readEngineRegistry(root, { persist: false }).engines
@@ -1226,7 +1397,7 @@ function renderSessionRoster(report, key) {
   const team = report.team.filter((row) => row.source === 'file' && row.file === report.files.session);
   if (!jobs.length && !team.length) return `this session (${key}) has no roster changes. add one with: atris engine assign <job> <tool> --session`;
   const head = `this session (${key}) changes${report.files.session ? `, from ${report.files.session}` : ''}`;
-  return [head, renderJobRoster(jobs), renderTeamRoster(team)].filter(Boolean).join('\n\n');
+  return [head, renderJobRoster(jobs, { heading: false }), renderTeamRoster(team)].filter(Boolean).join('\n\n');
 }
 
 function runRosterSessionCommand(rest, json, root, now) {
@@ -1275,6 +1446,38 @@ function attachRunRecords(report, root, now = new Date()) {
   return report;
 }
 
+// Pins are proven by landed runs; a pin older than 30 days is flagged, so
+// the look-back reaches well past that.
+const STALE_PROOF_DAYS = 90;
+
+// Each team row gets the member's activity (last 7 days, quiet, or idle)
+// from the same evidence atris team reads: dated logs, commits that name
+// the member, roster runs, and stream events, read once for the team.
+function attachTeamActivity(report, root, now = new Date()) {
+  const rows = report.team || [];
+  if (!rows.length) return report;
+  try {
+    const { collectMemberActivity } = require('./team');
+    const activity = collectMemberActivity(root, rows.map((row) => ({ name: row.member })), { nowMs: new Date(now).getTime() });
+    const byName = new Map(activity.map(({ days, ...rest }) => [rest.name, rest]));
+    for (const row of rows) row.activity = byName.get(String(row.member).toLowerCase()) || null;
+  } catch {
+    // Activity is a view; a read that fails leaves the roster as it was.
+  }
+  return report;
+}
+
+// Mark workers that run an outdated model or an unproven old pin. Local
+// files only: the registry, codex's models cache, and the run record.
+function attachStaleCheck(report, root, now = new Date()) {
+  const engines = readEngineRegistry(root, { persist: false }).engines;
+  return attachStaleModels(report, {
+    catalog: modelCatalog(engines),
+    runs: readRosterRuns(root, { now, days: STALE_PROOF_DAYS }),
+    now,
+  });
+}
+
 const RUNS_LIST_DAYS = 30;
 const RUNS_LIST_LIMIT = 20;
 
@@ -1321,9 +1524,9 @@ function runRosterCommand(args, root, now = new Date()) {
   }
   if (rest[0] === 'session') return runRosterSessionCommand(rest, json, root, now);
   if (rest[0] === 'confirm') confirmRoster(root, now);
-  const report = attachRunRecords(rosterReport(root, now), root, now);
+  const report = attachTeamActivity(attachStaleCheck(attachRunRecords(rosterReport(root, now), root, now), root, now), root, now);
   if (json) console.log(JSON.stringify(report, null, 2));
-  else console.log(`${renderRosterReport(report)}\n\n${AVAILABLE_HINT}`);
+  else console.log(`${renderRosterReport(report)}\n\n${TEAM_FOOTER.join('\n')}`);
   return 0;
 }
 
@@ -1530,9 +1733,30 @@ function parseSetFlag(args) {
   return '';
 }
 
-function runResolveCommand(args, root) {
+// One worker as a person reads it: the tool, then its model and effort.
+function notesWorkerText(worker) {
+  const details = [worker.model, worker.effort ? `effort ${worker.effort}` : '', worker.installed ? '' : 'not installed'].filter(Boolean);
+  return details.length ? `${worker.engine} (${details.join(', ')})` : worker.engine;
+}
+
+// The notes job: the roster's pick when one is set, else the built-in
+// default. Always answers, so scripts can call it with a short timeout.
+function runNotesResolve(json, root, now) {
+  const answer = resolveNotesJob(root, { now });
+  if (json) {
+    console.log(JSON.stringify(answer));
+    return 0;
+  }
+  const backup = answer.backup.length ? `backup ${answer.backup.map(notesWorkerText).join(', then ')}` : 'no backup';
+  const where = answer.source === 'roster' ? `from ${answer.from}` : `built-in default${answer.skipped ? ` (${answer.skipped})` : ''}`;
+  console.log(`notes: ${notesWorkerText(answer)}, ${backup}, ${where}`);
+  return 0;
+}
+
+function runResolveCommand(args, root, now) {
   const json = args.includes('--json');
   const role = args.filter((a) => !String(a).startsWith('--'))[0] || '';
+  if (role && rosterJobKey(role) === 'notes') return runNotesResolve(json, root, now);
   if (!role) {
     const message = `usage: atris engine resolve <role> or <job>; roles: ${ENGINE_ROLES.join(', ')}; jobs: search, build, review, or your own`;
     if (json) console.log(JSON.stringify({ ok: false, error: message }, null, 2));
@@ -2133,7 +2357,7 @@ function engineCommand(args = [], deps = {}) {
   }
 
   if (sub === 'resolve') {
-    return runResolveCommand(scope.args.slice(scope.args.indexOf('resolve') + 1), root);
+    return runResolveCommand(scope.args.slice(scope.args.indexOf('resolve') + 1), root, deps.now);
   }
 
   if (sub === 'health') {
@@ -2160,7 +2384,7 @@ function engineCommand(args = [], deps = {}) {
     if (sub === 'help' || args.includes('--help') || args.includes('-h')) {
       console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
       console.log('\n  long read-only asks: atris engine ask "..." --engine agy --timeout <seconds>\n                           quick asks default to 120 seconds; explicit jobs allow up to 3600\n                           follow live work with atris engine watch latest');
-      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n                           flags a model with a newer version on this machine, or a pin not proven in 30 days\n                           (a landed run, or "verified 2026-09-30" on its line, proves it)\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job;\n                           notes always answers: its roster pick, else agy then haiku\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
       return 0;
     }
     if (isFreshWorkspace(root)) {
@@ -2209,7 +2433,10 @@ module.exports = {
   readSavedEngine,
   roster,
   rosterReport,
+  renderRosterReport,
   jobRosterView,
+  expiringWorkers,
+  bootExpiringLine,
   engineRegistryFile,
   readEngineRegistry,
   resolveEngineForRole,

package/commands/feedback.js

@@ -17,6 +17,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const {
@@ -297,8 +298,7 @@ function resolveBusinessArg(value) {
   // Full UUID, trust it
   if (/^[0-9a-f-]{32,}$/i.test(value)) return value;
   // Otherwise treat as slug and look up in ~/.atris/businesses.json
-  const home = require('os').homedir();
-  const file = path.join(home, '.atris', 'businesses.json');
+  const file = path.join(stateHome(), '.atris', 'businesses.json');
   if (!fs.existsSync(file)) return null;
   try {
     const map = JSON.parse(fs.readFileSync(file, 'utf8'));

package/commands/fork.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 
@@ -48,7 +48,7 @@ async function forkAtris() {
     files = downloadResult.data.files;
   } else {
     // Fall back to local template at ~/.atris/templates/{template}/
-    const localTemplatePath = path.join(os.homedir(), '.atris', 'templates', template);
+    const localTemplatePath = path.join(stateHome(), '.atris', 'templates', template);
     if (fs.existsSync(localTemplatePath)) {
       console.log('  API unavailable, using local template...');
       files = readLocalTemplate(localTemplatePath, localTemplatePath);

package/commands/gm.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
@@ -452,7 +453,7 @@ function feedPostId(post) {
 }
 
 function credentialsFileExists() {
-  return fs.existsSync(path.join(os.homedir(), '.atris', 'credentials.json'));
+  return fs.existsSync(path.join(stateHome(), '.atris', 'credentials.json'));
 }
 
 async function fetchFeedEvents(workspaceRoot) {