atris 3.74.5 → 3.74.7

package/lib/gm-phone.js

@@ -317,6 +317,18 @@ function checkRequest(req, { token, hosts = [] }) {
     return { ok: false, status: 400, reason: 'url' };
   }
   if (!hosts.includes(host)) return { ok: false, status: 403, reason: 'host' };
+  // Another site is refused on every route, reads too: a page in the owner's
+  // browser that holds the key could otherwise read his cards. A fetch says
+  // where it came from in Origin or Sec-Fetch-Site; a scan or a typed link
+  // says none, and a plain client says nothing. The one exception is a
+  // top-level open of the page itself (a link tapped in a mail or chat app):
+  // a navigation cannot read anything, and the page load starts no work.
+  if (req.headers.origin != null && String(req.headers.origin) !== `http://${host}`) return { ok: false, status: 403, reason: 'origin' };
+  const site = String(req.headers['sec-fetch-site'] || '').toLowerCase();
+  const pageOpen = req.method === 'GET' && url.pathname === '/'
+    && String(req.headers['sec-fetch-mode'] || '').toLowerCase() === 'navigate'
+    && String(req.headers['sec-fetch-dest'] || '').toLowerCase() === 'document';
+  if (site && site !== 'same-origin' && site !== 'none' && !pageOpen) return { ok: false, status: 403, reason: 'site' };
   const header = req.headers['x-gm-token'];
   if (req.method === 'GET') {
     if (!tokenMatches(url.searchParams.get('t') || header, token)) return { ok: false, status: 403, reason: 'token' };
@@ -501,37 +513,21 @@ function createPhoneHandler(deps) {
     return { status: ok ? 200 : 500, body: { ok, ack: ok ? 'undone, target back how it was' : 'could not undo' } };
   }
 
-  // think shows the next card at once (a choice of ideas, one idea, or a
-  // question when none is ready); pick opens one idea from a choice; sharper
-  // asks for a new bet; answer saves the owner's answer to the question on
-  // screen; do it needs a second tap because it starts
-  // agents; not now only marks the bet skipped.
-  async function betAction(p, body) {
-    let out;
-    if (p === '/bet/think') out = bet.next({ sharper: body.sharper === true });
-    // typed words in something else are read first, like say something: a
-    // question back or confusion is explained and nothing is saved
-    else if (p === '/bet/answer' && body.choice === 'other') out = await bet.say({ text: String(body.text || ''), card: String(body.card || '') });
-    else if (p === '/bet/answer') out = bet.answer({ choice: String(body.choice || ''), text: String(body.text || ''), card: String(body.card || '') });
-    else if (p === '/bet/report') out = bet.report({ value: body.value });
-    else if (p === '/bet/pick') out = bet.pick({ id: String(body.id || '') });
-    else if (p === '/bet/steer') out = await bet.talk({ member: String(body.member || ''), text: String(body.text || ''), confirm: body.confirm === true, note: body.note === true });
-    else if (p === '/bet/say') out = await bet.say({ text: String(body.text || ''), confirm: body.confirm === true, note: body.note === true, card: String(body.card || '') });
-    else if (p === '/bet/skip') out = bet.skip();
-    // the engine card and its one-tap swap; the tap is the owner's approval
-    else if (p === '/bet/engine') out = await bet.engineCard({ member: String(body.member || '') });
-    else if (p === '/bet/swap') out = await bet.swapEngine({ member: String(body.member || ''), engine: String(body.engine || ''), model: String(body.model || ''), scope: String(body.scope || '') });
-    else if (p === '/bet/do') {
-      if (body.confirm !== true) return { status: 409, body: { ok: false, reason: 'needs_confirm', confirm_ms: CONFIRM_MS } };
-      out = await bet.doIt();
-    } else if (p === '/bet/nice') {
-      out = bet.nice();
-    } else if (p === '/bet/yes') {
-      // a yes unblocks agents, so it needs a second tap
-      if (body.confirm !== true) return { status: 409, body: { ok: false, reason: 'needs_confirm', confirm_ms: CONFIRM_MS } };
-      out = await bet.answerYes(typeof body.key === 'string' && body.key ? { key: body.key.slice(0, 300), job: typeof body.job === 'string' ? body.job.slice(0, 300) : '' } : {});
-    } else return { status: 404, body: { ok: false, reason: 'not_found' } };
-    return { status: out.ok ? 200 : 409, body: out };
+  // The one route for the card on screen (lib/gm-card.js): the card's id and
+  // one option on it, or typed words for its box, or the orb's next card, or
+  // the team or the job deck from the footer. The desk checks the card id
+  // and the option, and refuses anything else. A second tap is the page
+  // sending confirm on an option that asks for one.
+  function cardAction(body) {
+    const clean = {
+      card_id: typeof body.card_id === 'string' ? body.card_id.slice(0, 300) : null,
+      option_id: typeof body.option_id === 'string' ? body.option_id.slice(0, 120) : null,
+      confirm: body.confirm === true,
+      orb: body.orb === true,
+      open: body.open === 'team' || body.open === 'deck' ? body.open : null,
+    };
+    if (typeof body.text === 'string') clean.text = body.text.slice(0, 1000);
+    return Promise.resolve(bet.act(clean));
   }
 
   // A typed send carries its own id, made on the phone when the words are
@@ -542,11 +538,11 @@ function createPhoneHandler(deps) {
   const sends = new Map();
   function sendOnce(p, body) {
     const id = typeof body.send === 'string' && SEND_ID.test(body.send) ? `${p} ${body.send}` : null;
-    if (!id) return betAction(p, body);
+    if (!id) return cardAction(body);
     const seen = sends.get(id);
     if (seen && now() - seen.at < SENDS_MS) return seen.out;
     sends.delete(id);
-    const out = betAction(p, body);
+    const out = cardAction(body);
     sends.set(id, { at: now(), out });
     const forget = () => { if (sends.get(id) && sends.get(id).out === out) sends.delete(id); };
     out.then(r => { if (!r.body || r.body.ok !== true) forget(); }, forget);
@@ -579,10 +575,9 @@ function createPhoneHandler(deps) {
         });
       }
       if (req.method === 'GET' && check.path === '/state') return send(res, 200, state());
-      if (req.method === 'GET' && check.path === '/bet') return bet ? send(res, 200, bet.warm()) : send(res, 404, { ok: false, reason: 'not_found' });
-      if (req.method === 'GET' && check.path === '/bet/team') return bet ? send(res, 200, bet.teamTable()) : send(res, 404, { ok: false, reason: 'not_found' });
-      if (req.method === 'GET' && check.path === '/bet/jobs') return bet ? send(res, 200, bet.jobDeck()) : send(res, 404, { ok: false, reason: 'not_found' });
-      if (req.method === 'POST' && (check.path === '/action' || check.path === '/undo' || (bet && check.path.startsWith('/bet/')))) {
+      // the card on screen now; a read starts no work
+      if (req.method === 'GET' && check.path === '/card') return bet ? send(res, 200, bet.card()) : send(res, 404, { ok: false, reason: 'not_found' });
+      if (req.method === 'POST' && (check.path === '/action' || check.path === '/undo' || (bet && check.path === '/act'))) {
         if (String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase() !== 'application/json') return send(res, 415, { ok: false, reason: 'json_only' });
         let body;
         try {
@@ -591,7 +586,7 @@ function createPhoneHandler(deps) {
         } catch (err) {
           return send(res, err.message === 'too_large' ? 413 : 400, { ok: false, reason: 'bad_body' });
         }
-        if (check.path.startsWith('/bet/')) {
+        if (check.path === '/act') {
           const out = await sendOnce(check.path, body || {});
           return send(res, out.status, out.body);
         }

package/lib/idea-tick.js

@@ -186,6 +186,19 @@ function defaultRunLap(text, options) {
   return require('../commands/one-lap').runOneLap(text, options);
 }
 
+// Sealed builds get no keychain, so a Claude build with no saved login fails
+// at its first word. Saying so before the build keeps the idea's attempts.
+function defaultLoginGap(repo) {
+  try {
+    const executor = require('../commands/one-lap').readyExecutor(repo);
+    if (!executor || executor.id !== 'claude') return '';
+    if (process.env.CLAUDE_CODE_OAUTH_TOKEN || require('./engine-login').savedToken()) return '';
+    return 'no Claude login for sealed builds';
+  } catch {
+    return '';
+  }
+}
+
 // Where a stopped lap stopped: its check failed, its check passed but the
 // review did not, or it never got that far.
 function lapStage(lap) {
@@ -248,6 +261,7 @@ async function runIdeaTick({
   lockOptions = {},
   loopRepo = null,
   clock = () => Date.now(),
+  loginGap = runLap === defaultRunLap ? defaultLoginGap : () => '',
 } = {}) {
   const repo = path.resolve(root);
   const lock = acquireTickLock(repo, lockOptions);
@@ -282,6 +296,12 @@ async function runIdeaTick({
       return stop(idea, { stage: 'checks', cause: 'no fast check found', reason: `this repo has no fast check I can find; give one: atris idea retry ${idea.n} --verify "<cmd>"` });
     }
 
+    const gap = loginGap(repo);
+    if (gap) {
+      log(`idea ${idea.n} waits: ${gap}. run: atris idea login`);
+      return { status: 'needs_login', idea_id: idea.id, reason: gap };
+    }
+
     started = iso();
     current = updateIdea(repo, idea.id, { status: 'building', attempts: Number(idea.attempts || 0) + 1, started_at: started }) || idea;
     log(`building idea ${idea.n}: ${oneLine(idea.text, 80)}`);

package/lib/task-db.js

@@ -35,6 +35,8 @@ const { explicitDoneLooksLike, taskExplanation } = require('./task-explanation')
 const { treeHashFor } = require('./tree-hash');
 const { sleepSync } = require('./sleep-sync');
 const { atrisHome } = require('./state-home');
+const { careerXpRoot } = require('./career-xp-root');
+const { withCareerXpLock } = require('./career-xp-lock');
 
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
 const TODO_RENDER_DONE_LIMIT = 8;
@@ -2054,10 +2056,12 @@ function taskEpisodeFromRevision(row, event, payload) {
 }
 
 function appendTaskEpisode(workspaceRoot, episode) {
-  const filePath = path.join(workspaceRoot, TASK_EPISODES_FILE);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.appendFileSync(filePath, JSON.stringify(episode) + '\n', 'utf8');
-  return filePath;
+  const workspace = careerXpRoot(workspaceRoot);
+  return withCareerXpLock(workspace, () => {
+    const filePath = path.join(workspace, TASK_EPISODES_FILE);
+    fs.appendFileSync(filePath, JSON.stringify(episode) + '\n', 'utf8');
+    return filePath;
+  });
 }
 
 function clipProjectionText(value, max = PROJECTION_PAYLOAD_TEXT_LIMIT) {

package/lib/values.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+
+// The bold-lead bullets under `## values` in atris.md, each as its name and
+// its first sentence, so the boot can show them in every new chat instead of
+// leaving them deep in a long file. A workspace made before the values
+// shipped has no such section; the package copy stands in for it.
+function extractValues(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  const start = lines.findIndex((line) => /^## values\s*$/i.test(line));
+  if (start === -1) return [];
+  const values = [];
+  for (let index = start + 1; index < lines.length && !/^##\s+/.test(lines[index]); index += 1) {
+    const match = lines[index].match(/^- \*\*([^*]+?)\.\*\*\s+([^.]+)\./);
+    if (match) values.push({ name: match[1].toLowerCase(), gist: match[2][0].toLowerCase() + match[2].slice(1) });
+  }
+  return values;
+}
+
+function readValues(root) {
+  for (const file of [path.join(root, 'atris.md'), path.join(root, 'atris', 'atris.md')]) {
+    if (!fs.existsSync(file)) continue;
+    const found = extractValues(fs.readFileSync(file, 'utf8'));
+    if (found.length) return found;
+  }
+  return [];
+}
+
+function valuesForRoot(root = process.cwd()) {
+  const own = readValues(root);
+  return own.length ? own : readValues(PACKAGE_ROOT);
+}
+
+module.exports = { extractValues, valuesForRoot };

package/lib/yes-lock.js

@@ -322,7 +322,7 @@ function rowRequests(row) {
 // What a step looks like from outside: its newest waiting command, and its
 // yes that is given and not used yet.
 function stepSummary(requests) {
-  const pending = requests.filter(r => !r.approved_at && !r.used_at);
+  const pending = requests.filter(r => !r.approved_at && !r.used_at && !r.denied_at);
   const open = requests.find(r => r.approved_at && !r.used_at) || null;
   const used = requests.filter(r => r.used_at);
   const last = pending[pending.length - 1] || null;
@@ -370,7 +370,7 @@ function approveYesLock(stateDir, missionId, step, seal, at = new Date().toISOSt
   const { locks } = effectiveLocks(stateDir, missionId, seal || sealFromState(stateDir, missionId));
   const lock = locks.find(l => l.step === step);
   if (!lock) return null;
-  const waiting = lock.requests.filter(r => !r.approved_at && !r.used_at);
+  const waiting = lock.requests.filter(r => !r.approved_at && !r.used_at && !r.denied_at);
   const target = hash ? waiting.find(r => r.hash === hash) : waiting[waiting.length - 1];
   if (!target) return null;
   target.approved_at = at || new Date().toISOString();
@@ -378,6 +378,20 @@ function approveYesLock(stateDir, missionId, step, seal, at = new Date().toISOSt
   return { ...lock, ...stepSummary(lock.requests), approved: target };
 }
 
+// The owner's no: the one waiting request with that hash is told no for good.
+// It never runs, its card is gone, and asking again only hears the no.
+// Without a hash (an older caller), the newest waiting request on the step.
+function denyYesLock(stateDir, missionId, step, { hash = null, at = new Date().toISOString() } = {}) {
+  const { locks } = effectiveLocks(stateDir, missionId, sealFromState(stateDir, missionId));
+  const lock = locks.find(l => l.step === step);
+  const waiting = lock ? lock.requests.filter(r => !r.approved_at && !r.used_at && !r.denied_at) : [];
+  const target = hash ? waiting.find(r => r.hash === hash) : waiting[waiting.length - 1];
+  if (!target) return null;
+  target.denied_at = at;
+  saveLocks(stateDir, missionId, locks);
+  return { ...lock, denied: target };
+}
+
 // For readers that have no mission record at hand (the desk), the state file
 // is its own seal: it is only ever used to show and answer cards, never to let
 // a command through.
@@ -393,7 +407,7 @@ function askedYesLocks(stateDir, missionId) {
   const cards = [];
   for (const row of data.locks) {
     for (const r of rowRequests(row)) {
-      if (r.approved_at || r.used_at) continue;
+      if (r.approved_at || r.used_at || r.denied_at) continue;
       cards.push({ step: row.step, text: row.text, categories: row.categories, held_command: r.command, held_key: r.key, hash: r.hash, asked_at: r.asked_at });
     }
   }
@@ -1156,6 +1170,10 @@ function check({ stateDir, missionId, seal, tool, args = [], gitBin = null, cwd
     saveLocks(stateDir, missionId, locks);
     return { consume: owners.map(l => l.step), claims };
   }
+  // the owner said no to this exact command: it stays held, and no new card is asked
+  if (owners.some(l => l.requests.some(r => r.hash === hash && r.denied_at && !r.approved_at))) {
+    return { hold: true, steps: owners.map(l => l.step), message: `held: the owner said no to "${shown}". do not run it again; leave it undone and go on with the rest.` };
+  }
   // held: a request on each step still missing a yes, one per exact command
   owners.forEach((lock, n) => {
     if (ready[n]) return;
@@ -1190,6 +1208,7 @@ module.exports = {
   gitContext,
   approveYesLock,
   askedYesLocks,
+  denyYesLock,
   check,
   consume,
   effectiveLocks,

package/lib/zen-apply.js

@@ -16,6 +16,7 @@ const {
   checkZen,
   defaultBranch,
   dirtyEntries,
+  folderLinksOnly,
   dirtyFiles,
   FRESH_MINUTES,
   gitOut,
@@ -26,6 +27,7 @@ const {
   mtime,
   idleWithOnlyNotes,
   lastTouched,
+  nextSaveIn,
   sideCopyLines,
   scheduledCopies,
   untrackedFiles,
@@ -151,6 +153,19 @@ function putAwaySideCopies(root, cutoff, staleCutoff, tag, teamState) {
       busy.push(wt.path);
       continue;
     }
+    // A copy whose only changes are links to ignored folders is clean: the
+    // links go, then the copy, and they come back if git will not remove it.
+    const links = status.stdout.trim() ? folderLinksOnly(wt.path, root) : [];
+    if (links.length) {
+      const targets = links.map((rel) => [path.join(wt.path, rel), fs.readlinkSync(path.join(wt.path, rel))]);
+      for (const [at] of targets) fs.unlinkSync(at);
+      if (runGit(['worktree', 'remove', wt.path], root).status === 0) removed += 1;
+      else {
+        for (const [at, to] of targets) fs.symlinkSync(to, at);
+        busy.push(wt.path);
+      }
+      continue;
+    }
     if (status.stdout.trim()) {
       // Unsaved work nobody has touched in days goes to a branch, then away.
       // So does an idle copy holding only team notes: nothing in it is work.
@@ -529,7 +544,7 @@ function applyZen({ cwd = process.cwd(), fetch = true, freshMinutes, abandonedDa
     done.push(`saved ${plural(copies.kept.length, 'side copy', 'side copies')} untouched for ${plural(staleDays, 'day', 'days')} to zen-backup/ and put ${copies.kept.length === 1 ? 'it' : 'them'} away`);
     saved.push(...copies.kept.map((b) => `refs/heads/${b}`));
   }
-  if (copies.busy.length) left.push(...sideCopyLines(copies.busy, staleDays));
+  if (copies.busy.length) left.push(...sideCopyLines(copies.busy, staleDays, nextSaveIn(copies.busy, staleDays, now.getTime())));
   if (copies.scheduled) left.push(`${plural(copies.scheduled, 'side copy is', 'side copies are')} used by a scheduled job, so ${copies.scheduled === 1 ? 'it stays' : 'they stay'}`);
   if (copies.locked) left.push(`${plural(copies.locked, 'side copy is', 'side copies are')} locked by ${copies.locked === 1 ? 'its owner, so it stays' : 'their owners, so they stay'}`);
   if (copies.inUse) left.push(`${plural(copies.inUse, 'side copy was', 'side copies were')} used in ${window}`);
@@ -623,6 +638,7 @@ function applyZen({ cwd = process.cwd(), fetch = true, freshMinutes, abandonedDa
     notes,
     saved,
     team_files: after.team_files,
+    team_places: after.team_places,
     remaining: after.problems.map((p) => p.text),
   };
   try {

package/lib/zen.js

@@ -107,6 +107,19 @@ function dirtyFiles(root) {
     : [entry.path]));
 }
 
+// Where unsaved team files sit, by top folder (or file at the root),
+// biggest first and ties by name: [{ place: 'atris/', count: 52 }, ...].
+function placeCounts(files) {
+  const counts = new Map();
+  for (const file of files) {
+    const slash = file.indexOf('/');
+    const place = slash === -1 ? file : file.slice(0, slash + 1);
+    counts.set(place, (counts.get(place) || 0) + 1);
+  }
+  return [...counts].map(([place, count]) => ({ place, count }))
+    .sort((a, b) => b.count - a.count || (a.place < b.place ? -1 : a.place > b.place ? 1 : 0));
+}
+
 function listWorktrees(root) {
   const out = gitOut(['worktree', 'list', '--porcelain'], root) || '';
   const worktrees = [];
@@ -218,6 +231,27 @@ function lastTouched(checkout) {
   return newest;
 }
 
+// Links a side copy holds where the repo ignores a folder, like node_modules
+// pointing at another checkout's packages. A link holds no work, but git only
+// matches `node_modules/` against a real folder, so it reads as unsaved. The
+// rule is asked of the main checkout, where that path is not a link. Empty
+// when anything else in the copy changed.
+function folderLinksOnly(checkout, root) {
+  const entries = dirtyEntries(checkout);
+  const links = [];
+  for (const entry of entries) {
+    if (entry.xy !== '??') return [];
+    const rel = entry.path.replace(/\/+$/, '');
+    let link = false;
+    try {
+      link = fs.lstatSync(path.join(checkout, rel)).isSymbolicLink();
+    } catch {}
+    if (!link || runGit(['check-ignore', '-q', `${rel}/`], root).status !== 0) return [];
+    links.push(rel);
+  }
+  return links;
+}
+
 // A side copy whose only changes are team notes, untouched and not switched
 // or committed in the fresh window, holds nothing anyone is working on. Live
 // data files never count as notes, so a copy holding one is left alone.
@@ -265,14 +299,37 @@ function lastEntryTime(log) {
   }
 }
 
-// True when a checkout switched or made a commit after the cutoff.
-function headMovedSince(checkout, cutoff) {
+// When a checkout last switched or made a commit.
+function headTime(checkout) {
   const gitDir = gitOut(['rev-parse', '--git-dir'], checkout);
-  if (!gitDir) return false;
+  if (!gitDir) return 0;
   const dir = path.resolve(checkout, gitDir);
   const logged = lastEntryTime(path.join(dir, 'logs', 'HEAD'));
-  if (logged !== null) return logged > cutoff;
-  return Math.max(mtime(path.join(dir, 'logs', 'HEAD')), mtime(path.join(dir, 'HEAD'))) > cutoff;
+  if (logged !== null) return logged;
+  return Math.max(mtime(path.join(dir, 'logs', 'HEAD')), mtime(path.join(dir, 'HEAD')));
+}
+
+// True when a checkout switched or made a commit after the cutoff.
+function headMovedSince(checkout, cutoff) {
+  return headTime(checkout) > cutoff;
+}
+
+// How long until the first of these side copies has sat untouched long
+// enough for zen to save it, or null when none is waiting on the clock.
+function nextSaveIn(paths, days, now = Date.now()) {
+  let soonest = null;
+  for (const p of paths) {
+    const wait = Math.max(headTime(p), lastTouched(p)) + days * 86400000 - now;
+    if (wait > 0 && (soonest === null || wait < soonest)) soonest = wait;
+  }
+  return soonest;
+}
+
+function waitText(ms) {
+  const hours = Math.ceil(ms / 3600000);
+  if (hours < 24) return `${hours} ${hours === 1 ? 'hour' : 'hours'}`;
+  const days = Math.round(hours / 24);
+  return `${days} ${days === 1 ? 'day' : 'days'}`;
 }
 
 // True when a branch was made or moved after the cutoff. A running job makes
@@ -334,6 +391,7 @@ function checkZen({ cwd = process.cwd(), fetch = true, freshMinutes = freshMinut
   const dirty = dirtyFiles(root);
   const stray = dirty.filter((file) => !isTeamState(file, teamState));
   const teamFiles = dirty.length - stray.length;
+  const teamPlaces = placeCounts(dirty.filter((file) => isTeamState(file, teamState)));
   if (stray.length) {
     problems.push({
       kind: 'stray_code',
@@ -367,7 +425,7 @@ function checkZen({ cwd = process.cwd(), fetch = true, freshMinutes = freshMinut
     }
     const status = runGit(['status', '--porcelain'], wt.path);
     if (status.status !== 0) busy.push(wt);
-    else if (status.stdout.trim()) (idleWithOnlyNotes(wt.path, teamState, cutoff) ? notesOnly : busy).push(wt);
+    else if (status.stdout.trim() && !folderLinksOnly(wt.path, root).length) (idleWithOnlyNotes(wt.path, teamState, cutoff) ? notesOnly : busy).push(wt);
     else if (headMovedSince(wt.path, cutoff)) inUse.push(wt);
     else idle.push(wt);
   }
@@ -415,6 +473,7 @@ function checkZen({ cwd = process.cwd(), fetch = true, freshMinutes = freshMinut
     ahead,
     behind,
     team_files: teamFiles,
+    team_places: teamPlaces,
     stashes,
     worktrees_with_work: busy.map((wt) => wt.path),
     worktrees_in_use: inUse.map((wt) => wt.path),
@@ -424,27 +483,44 @@ function checkZen({ cwd = process.cwd(), fetch = true, freshMinutes = freshMinut
   };
 }
 
-// Where the side copies are, so a line about them can be acted on: home
-// shortened to ~, at most three named.
-// Side copies left with unsaved work: one place per line so a long path
-// still fits a narrow pane, then when zen will take them over.
-function sideCopyLines(paths, days) {
+// A place a person can paste: home as ~, and the system temp folder (git
+// may report it through /private) as $TMPDIR when that variable is set, so a
+// test leftover there fits a narrow pane.
+function shortPlace(p) {
   const home = os.homedir();
+  const tmp = (process.env.TMPDIR || '').replace(/\/+$/, '');
+  if (tmp) {
+    let real = tmp;
+    try {
+      real = fs.realpathSync(tmp);
+    } catch {}
+    for (const dir of new Set([tmp, real])) {
+      if (p === dir || p.startsWith(dir + path.sep)) return `$TMPDIR${p.slice(dir.length)}`;
+    }
+  }
+  return p === home || p.startsWith(home + path.sep) ? `~${p.slice(home.length)}` : p;
+}
+
+// Side copies left with unsaved work: at most three named, one place per
+// line so a long path still fits a narrow pane, then when zen will take
+// them over and, when known, how long until the first one goes.
+function sideCopyLines(paths, days, waitMs = null) {
   const n = paths.length;
   const lines = [`${n} side ${n === 1 ? 'copy has' : 'copies have'} unsaved work, left for ${n === 1 ? 'its owner' : 'their owners'}`];
-  for (const p of paths.slice(0, 3)) {
-    lines.push(`  ${p === home || p.startsWith(home + path.sep) ? `~${p.slice(home.length)}` : p}`);
-  }
+  for (const p of paths.slice(0, 3)) lines.push(`  ${shortPlace(p)}`);
   if (n > 3) lines.push(`  and ${n - 3} more`);
   lines.push(`zen saves ${n === 1 ? 'it' : 'each one'} to zen-backup/ once nobody has touched it for ${days} ${days === 1 ? 'day' : 'days'}`);
+  if (waitMs > 0) lines.push(`${n === 1 ? 'that is' : 'the first one is'} due in ${waitText(waitMs)}`);
   return lines;
 }
 
 module.exports = {
   ABANDONED_DAYS,
   branchMovedSince,
+  folderLinksOnly,
   idleWithOnlyNotes,
   lastTouched,
+  nextSaveIn,
   untrackedFiles,
   abandonedDaysFromEnv,
   sideCopyLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.5",
+  "version": "3.74.7",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",