atris 3.63.0 → 3.64.0

package/commands/engine.js

@@ -69,6 +69,8 @@ const {
   readEngineRegistry,
   resolveEngineForRole,
   resolveEngineForRoleRanked,
+  resolveNotesJob,
+  jobTakesAnyEngine,
   requireEngineBin,
   engineDoctorReport,
   engineFailureHealthStatus,
@@ -1000,10 +1002,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 +1049,8 @@ 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),
     line: worker.line || null,
     ...(worker.error ? { text: worker.text || '' } : {}),
     status,
@@ -1041,7 +1076,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 +1090,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 +1112,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 +1152,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,12 +1168,52 @@ 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';
 }
 
+// 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}`;
+}
+
+// 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}`;
+}
+
 // 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) {
@@ -1140,8 +1221,11 @@ function renderWorkerLines(row) {
   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}`;
+    const ended = worker.status === 'skipped' && worker.why === 'expired' && worker.ends_in_days !== null;
+    const until = !worker.until || ended ? '' : `until ${worker.until}${worker.expiring_soon ? `, ${endsInText(worker.ends_in_days)}` : ''}`;
+    const extras = [worker.max_seconds ? rosterMaxText(worker.max_seconds) : '', worker.prep ? `prepped by ${worker.prep}` : '', until].filter(Boolean);
+    const state = worker.status === 'leads' ? 'leads now' : worker.status === 'backup' ? 'backup'
+      : ended ? `ended ${shortDay(worker.until)}, skipped` : `skipped, ${worker.why}`;
     return `  ${index + 1}. ${what} ${[state, ...extras].join(', ')}`.trimEnd();
   });
 }
@@ -1165,9 +1249,10 @@ function renderJobRoster(rows) {
     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 date = untilText(row.pick, row.ends_in_days);
     const fallback = row.lead === 'backup' ? 'using backup' : row.lead === 'later' ? `using ${nowText}` : fallsTo;
-    const status = row.status === 'expired' ? `expired, ${fallback}`
+    const ended = row.ends_in_days !== null && row.ends_in_days !== undefined ? `ended ${shortDay(row.pick.until)}, skipped` : 'expired';
+    const status = row.status === 'expired' ? `${ended}, ${fallback}`
       : row.status === 'cooling' ? `${row.cooling}, ${fallback}`
         : row.status === 'not ready' ? `not ready, ${fallback}`
           : date;
@@ -1195,7 +1280,8 @@ function renderRosterWarnings(warnings) {
 }
 
 function renderRosterReport(report) {
-  return [renderJobRoster(report.jobs), renderTeamRoster(report.team), renderRosterWarnings(report.warnings)]
+  const jobs = [renderJobRoster(report.jobs), renderExpiringLine(report.expiring)].filter(Boolean).join('\n');
+  return [jobs, renderTeamRoster(report.team), renderRosterWarnings(report.warnings)]
     .filter(Boolean)
     .join('\n\n');
 }
@@ -1530,9 +1616,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 +2240,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 +2267,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  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)) {
@@ -2210,6 +2317,8 @@ module.exports = {
   roster,
   rosterReport,
   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) {

package/commands/improve.js

@@ -18,10 +18,13 @@
  * fallback, and scorecard writes can all be faked in tests.
  */
 
+const crypto = require('crypto');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const gitSpawn = require('../lib/git-spawn');
+const ignoredCache = require('../lib/ignored-cache');
 const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
 const { loadCredentials } = require('../utils/auth');
 const pulse = require('../lib/pulse');
@@ -1085,8 +1088,9 @@ function parseRevisionsArgs(argv = []) {
   return opts;
 }
 
-function gitLines(cwdRoot, gitArgs) {
-  const r = spawnSync('git', gitArgs, { cwd: cwdRoot, encoding: 'utf8' });
+// Through the module object so tests can count git spawns with a spy.
+function gitLines(cwdRoot, gitArgs, { input, maxBuffer } = {}) {
+  const r = gitSpawn.runGit(gitArgs, { cwd: cwdRoot, check: false, input, maxBuffer });
   if (r.status !== 0) {
     const err = new Error(String(r.stderr || `git ${gitArgs[0]} exited ${r.status}`).trim());
     err.gitFailed = true;
@@ -1095,17 +1099,129 @@ function gitLines(cwdRoot, gitArgs) {
   return String(r.stdout || '');
 }
 
+// File names come back NUL-separated and never quoted, whatever core.quotePath
+// says, so a name reads the same fresh from git and from the saved cache.
+const NAME_ARGS = ['-c', 'core.quotePath=false'];
+
+function splitNames(out) {
+  return String(out || '').split('\0').filter(Boolean);
+}
+
 /**
  * Files changed by one commit. Merge commits are attributed by their
  * first-parent diff (what the merge actually brought onto the mainline);
  * plain commits use diff-tree. Root commits list their initial files.
+ * The rename choice is spelled out so a user's diff.renames setting cannot
+ * change the lists: merges find renames (git diff's default), plain commits
+ * do not (diff-tree's default).
  */
 function commitFiles(cwdRoot, commit) {
   const parents = commit.parents;
   const out = parents.length >= 2
-    ? gitLines(cwdRoot, ['diff', '--name-only', `${commit.hash}^1`, commit.hash])
-    : gitLines(cwdRoot, ['diff-tree', '--no-commit-id', '--name-only', '-r', '--root', commit.hash]);
-  return out.split('\n').map((line) => line.trim()).filter(Boolean);
+    ? gitLines(cwdRoot, [...NAME_ARGS, 'diff', '--name-only', '--find-renames', '-z', `${commit.hash}^1`, commit.hash])
+    : gitLines(cwdRoot, [...NAME_ARGS, 'diff-tree', '--no-commit-id', '--name-only', '--no-renames', '-z', '-r', '--root', commit.hash]);
+  return splitNames(out);
+}
+
+/**
+ * Files changed by many plain commits in one git process: the same diff-tree
+ * per-commit call above, fed every hash on stdin. --always prints the hash
+ * even for an empty commit. Raw output frames every file as a ':'-led status
+ * field followed by its path, so a path is never mistaken for a commit hash,
+ * even a path spelled exactly like the next one.
+ */
+function plainCommitFiles(cwdRoot, commits) {
+  const found = new Map(commits.map((commit) => [commit.hash, []]));
+  if (!commits.length) return found;
+  const hashes = commits.map((commit) => commit.hash);
+  const out = gitLines(cwdRoot, [...NAME_ARGS, 'diff-tree', '--stdin', '--always', '--raw', '--no-renames', '-z', '-r', '--root'], {
+    input: `${hashes.join('\n')}\n`,
+    // Many commits' lists in one reply; the per-commit calls each had 1MB.
+    maxBuffer: Math.max(1, hashes.length) * 1024 * 1024,
+  });
+  const fields = splitNames(out);
+  let current = null;
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    if (field.startsWith(':')) {
+      // Status field; with --no-renames exactly one path follows it.
+      if (current && i + 1 < fields.length) current.push(fields[i + 1]);
+      i += 1;
+    } else {
+      current = found.get(field) || null;
+    }
+  }
+  return found;
+}
+
+// Where git keeps state shared by every checkout of this repo (a linked
+// worktree points at its main repo). null when it cannot be found on disk.
+function gitCommonDir(root) {
+  if (process.env.GIT_DIR || process.env.GIT_COMMON_DIR) return null;
+  let dir = path.resolve(root);
+  for (;;) {
+    const dotGit = path.join(dir, '.git');
+    let stat = null;
+    try { stat = fs.statSync(dotGit); } catch { stat = null; }
+    if (stat && stat.isDirectory()) return dotGit;
+    if (stat && stat.isFile()) {
+      const match = fs.readFileSync(dotGit, 'utf8').match(/^gitdir:\s*(.+)$/m);
+      if (!match) return null;
+      const gitDir = path.resolve(dir, match[1].trim());
+      try {
+        return path.resolve(gitDir, fs.readFileSync(path.join(gitDir, 'commondir'), 'utf8').trim());
+      } catch {
+        return gitDir;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// A shallow clone cuts history at boundary commits, and those commits list
+// different files once the history is fetched. The saved lists are only good
+// for the shallow state they were read under; null means do not cache.
+function shallowStamp(root) {
+  const common = gitCommonDir(root);
+  if (!common) return null;
+  try {
+    return crypto.createHash('sha1').update(fs.readFileSync(path.join(common, 'shallow'))).digest('hex');
+  } catch (error) {
+    return error.code === 'ENOENT' ? 'full' : null;
+  }
+}
+
+// A commit's file list never changes, so it is saved by hash in the ignored
+// .atris/cache and the gauge (shown on every boot) only asks git about commits
+// it has not seen. Hashes this read used come first; older ones stay until the
+// cap, so a 7-day boot read and a 14-day report read do not evict each other.
+const REVISION_FILES_CACHE = 'revision-files.json';
+const REVISION_FILES_CACHE_MAX = 5000;
+
+function loadRevisionFilesCache(root) {
+  const shallow = ignoredCache.cacheEnabled(root) ? shallowStamp(root) : null;
+  const cache = { root, shallow, entries: {}, used: {}, dirty: false, writable: Boolean(shallow) };
+  if (!cache.writable) return cache;
+  const parsed = ignoredCache.readCacheJson(root, REVISION_FILES_CACHE);
+  if (parsed && parsed.version === 1 && parsed.shallow === shallow && parsed.entries && typeof parsed.entries === 'object') {
+    cache.entries = parsed.entries;
+  }
+  return cache;
+}
+
+function saveRevisionFilesCache(cache) {
+  if (!cache.writable || !cache.dirty) return;
+  const entries = { ...cache.used };
+  let count = Object.keys(entries).length;
+  for (const [hash, files] of Object.entries(cache.entries)) {
+    if (count >= REVISION_FILES_CACHE_MAX) break;
+    if (entries[hash] || !Array.isArray(files)) continue;
+    entries[hash] = files;
+    count += 1;
+  }
+  ignoredCache.writeCacheJson(cache.root, REVISION_FILES_CACHE, { version: 1, shallow: cache.shallow, entries });
 }
 
 /**
@@ -1150,10 +1266,27 @@ function collectRevisionSignals(root, options = {}) {
   // commits count as revision signals.
   const humans = commits.filter((c) => !c.isAgent && c.parents.length < 2);
 
-  const filesCache = new Map();
+  // Every landing's files are needed, and a human commit's only when it falls
+  // inside some landing's window. Plain commits missing from the cache are
+  // read in one batch; merges keep their own first-parent diff.
+  const cache = loadRevisionFilesCache(root);
+  const needed = [...landings, ...humans.filter((human) => landings.some((landing) => human.ms > landing.ms && human.ms <= landing.ms + REVISION_WINDOW_MS))];
+  const missing = [];
+  for (const commit of needed) {
+    const hit = cache.entries[commit.hash];
+    if (Array.isArray(hit)) cache.used[commit.hash] = hit;
+    else if (commit.parents.length < 2) missing.push(commit);
+  }
+  for (const [hash, files] of plainCommitFiles(root, missing)) {
+    cache.used[hash] = files;
+    cache.dirty = true;
+  }
   const filesOf = (commit) => {
-    if (!filesCache.has(commit.hash)) filesCache.set(commit.hash, commitFiles(root, commit));
-    return filesCache.get(commit.hash);
+    if (!cache.used[commit.hash]) {
+      cache.used[commit.hash] = commitFiles(root, commit);
+      cache.dirty = true;
+    }
+    return cache.used[commit.hash];
   };
 
   const revisions = [];
@@ -1177,6 +1310,7 @@ function collectRevisionSignals(root, options = {}) {
       });
     }
   }
+  saveRevisionFilesCache(cache);
 
   return {
     schema: REVISIONS_SCHEMA,

package/commands/integrations.js

@@ -33,11 +33,12 @@ const {
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
 const { sleepSync } = require('../lib/sleep-sync');
 
-const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
+const CALENDAR_CACHE_PATH = path.join(stateHome(), '.atris', 'calendar-events-cache.json');
 const GMAIL_CONNECT_POLL_MS = 3000;
 const GMAIL_CONNECT_TIMEOUT_MS = 3 * 60 * 1000;
 const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>]';
@@ -182,7 +183,7 @@ function parseGmailVerdictsArgs(args = []) {
 
 function gmailAccountStatePath() {
   return process.env.ATRIS_GMAIL_ACCOUNT_FILE
-    || path.join(os.homedir(), '.atris', 'gmail-account.json');
+    || path.join(stateHome(), '.atris', 'gmail-account.json');
 }
 
 function readGmailStickyAccount() {
@@ -1794,7 +1795,7 @@ function normalizeContactLabel(value) {
 }
 
 function imessageLookupCachePath() {
-  return path.join(os.homedir(), '.atris', 'cache', 'imessage-contacts.json');
+  return path.join(stateHome(), '.atris', 'cache', 'imessage-contacts.json');
 }
 
 function readImessageLookupCache() {

package/commands/loops.js

@@ -13,6 +13,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('../lib/state-home');
 const { execSync, spawnSync } = require('child_process');
 
 const MAX_LOG_AGE_DAYS = 14;
@@ -26,7 +27,7 @@ const SCAFFOLD_FILES = [
 ];
 
 function heartbeatDir() {
-  return process.env.ATRIS_HEARTBEAT_DIR || path.join(os.homedir(), '.atris', 'heartbeat');
+  return process.env.ATRIS_HEARTBEAT_DIR || path.join(stateHome(), '.atris', 'heartbeat');
 }
 
 function readJson(filePath, fallback) {