atris 3.56.3 → 3.57.0

package/commands/integrations.js

@@ -5,7 +5,8 @@
  *   atris gmail inbox [--account <id>]       - List recent emails for a mailbox
  *   atris gmail read <id> [--account <id>]   - Read specific email
  *   atris gmail archive <id> [...] [--account <id>] - Archive messages
- *   atris gmail verdicts [--account <id>] [--limit N] - List recent archive verdicts
+ *   atris gmail triage [--account <id>] [--limit N] - Record keep or archive verdicts
+ *   atris gmail verdicts [--account <id>] [--limit N] - List recent Gmail verdicts
  *   atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - Send an email
  *   atris gmail voice [account] [--clear]    - Edit an account's writing voice
  *   atris gmail connect [name]              - Connect or reconnect a Gmail account
@@ -40,7 +41,18 @@ 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>]';
 const GMAIL_VOICE_USAGE = 'usage: atris gmail voice [account] [--clear]';
+const GMAIL_TRIAGE_USAGE = 'usage: atris gmail triage [--account <id>] [--limit N]';
 const GMAIL_VERDICTS_USAGE = 'usage: atris gmail verdicts [--account <id>] [--limit N]';
+const GMAIL_BULK_DOMAINS = [
+  'campaign-archive.com',
+  'constantcontact.com',
+  'hubspotemail.net',
+  'mailchimp.com',
+  'mailchimpapp.net',
+  'mailgun.org',
+  'sendgrid.net',
+  'substack.com',
+];
 
 function gmailVerdictsPath(root = process.cwd()) {
   return path.join(root, '.atris', 'state', 'gmail-verdicts.jsonl');
@@ -54,7 +66,7 @@ function appendGmailVerdicts(verdicts, options = {}) {
   const lines = rows.map((row) => JSON.stringify({
     ts: row.ts || new Date().toISOString(),
     account: String(row.account || ''),
-    verdict: 'archive',
+    verdict: row.verdict === 'keep' ? 'keep' : 'archive',
     message_id: String(row.message_id || ''),
     ...(row.from ? { from: row.from } : {}),
     ...(row.subject ? { subject: row.subject } : {}),
@@ -90,11 +102,28 @@ function printGmailVerdicts(options = {}) {
   }
   for (const row of rows) {
     const details = [row.from && `from ${row.from}`, row.subject && `subject ${row.subject}`].filter(Boolean);
-    console.log(`${row.ts} archive ${row.message_id} account ${row.account}${details.length ? `, ${details.join(', ')}` : ''}`);
+    console.log(`${row.ts} ${row.verdict || 'archive'} ${row.message_id} account ${row.account}${details.length ? `, ${details.join(', ')}` : ''}`);
   }
   return rows;
 }
 
+function parseGmailTriageArgs(args = []) {
+  let accountId = null;
+  let limit = 25;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const value = String(args[i + 1] || '').trim();
+    if (arg === '--account' && value && !value.startsWith('--')) accountId = value;
+    else if (arg === '--limit' && /^\d+$/.test(value) && Number(value) > 0) limit = Number(value);
+    else {
+      console.error(GMAIL_TRIAGE_USAGE);
+      process.exit(1);
+    }
+    i += 1;
+  }
+  return { accountId, limit };
+}
+
 function parseGmailVerdictsArgs(args = []) {
   let account = null;
   let limit = 20;
@@ -278,8 +307,10 @@ async function gmailInbox(options = {}) {
   const account = findGmailAccount(accounts, accountId);
   const mailboxEmail = account ? gmailAccountIdentity(account).email : '';
 
-  if (mailboxEmail) console.log(`inbox for ${mailboxEmail} (${accountId.toLowerCase()})`);
-  console.log('📬 Fetching inbox...\n');
+  if (!options.quiet) {
+    if (mailboxEmail) console.log(`inbox for ${mailboxEmail} (${accountId.toLowerCase()})`);
+    console.log('📬 Fetching inbox...\n');
+  }
 
   const path = `/integrations/gmail/messages?max_results=${limit}&account_id=${encodeURIComponent(accountId)}`;
 
@@ -299,13 +330,16 @@ async function gmailInbox(options = {}) {
     process.exit(1);
   }
 
-  const messages = result.data?.messages || result.data || [];
+  const payload = result.data?.messages || result.data || [];
+  const messages = Array.isArray(payload) ? payload : [];
 
   if (messages.length === 0) {
-    console.log('No messages found.');
-    return;
+    if (!options.quiet) console.log('No messages found.');
+    return messages;
   }
 
+  if (options.quiet) return messages;
+
   console.log(`Found ${messages.length} messages:\n`);
   console.log('─'.repeat(60));
 
@@ -321,6 +355,69 @@ async function gmailInbox(options = {}) {
     console.log(`ID:   ${id}`);
     console.log('─'.repeat(60));
   }
+
+  return messages;
+}
+
+function gmailMessageHeaderText(message = {}) {
+  const lines = [];
+  const headers = message.headers;
+  if (Array.isArray(headers)) {
+    for (const header of headers) {
+      lines.push(`${String(header?.name || '')}: ${String(header?.value || '')}`);
+    }
+  } else if (headers && typeof headers === 'object') {
+    for (const [name, value] of Object.entries(headers)) lines.push(`${name}: ${String(value || '')}`);
+  } else if (headers) {
+    lines.push(String(headers));
+  }
+
+  for (const name of ['list_id', 'list_unsubscribe', 'mailing_list', 'unsubscribe']) {
+    if (message[name]) lines.push(`${name}: ${String(message[name])}`);
+  }
+  return lines.join('\n').toLowerCase();
+}
+
+function gmailTriageVerdict(message = {}) {
+  const from = String(message.from || message.sender || '').toLowerCase();
+  if (/(?:^|[^a-z0-9])(?:no[-_.]?reply|do[-_.]?not[-_.]?reply)(?:[^a-z0-9]|$)/i.test(from)) {
+    return 'archive';
+  }
+
+  const domain = from.match(/@([a-z0-9.-]+)/i)?.[1] || '';
+  if (GMAIL_BULK_DOMAINS.some((bulkDomain) => domain === bulkDomain || domain.endsWith(`.${bulkDomain}`))) {
+    return 'archive';
+  }
+
+  const headers = gmailMessageHeaderText(message);
+  if (/(?:^|\n)(?:list-id|list-unsubscribe|mailing-list|x-campaign-id|x-mailing-list)\s*:/i.test(headers)
+    || /(?:^|\n)precedence\s*:\s*(?:bulk|junk|list)/i.test(headers)
+    || /\bunsubscribe\b/i.test(headers)) {
+    return 'archive';
+  }
+
+  return 'keep';
+}
+
+async function gmailTriage(options = {}) {
+  const accountId = resolveGmailAccountId(options.accountId);
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 25;
+  const messages = await gmailInbox({ accountId, limit, quiet: true });
+  const ts = new Date().toISOString();
+  const rows = messages.map((message) => ({
+    ts,
+    account: accountId,
+    verdict: gmailTriageVerdict(message),
+    message_id: String(message.id || message.message_id || ''),
+    from: String(message.from || message.sender || 'Unknown'),
+    subject: String(message.subject || '(no subject)'),
+  }));
+  appendGmailVerdicts(rows, { root: options.root, filePath: options.filePath });
+
+  const keepCount = rows.filter((row) => row.verdict === 'keep').length;
+  const archiveCount = rows.length - keepCount;
+  console.log(`gmail triage recorded ${keepCount} keep and ${archiveCount} archive verdict${rows.length === 1 ? '' : 's'}.`);
+  return rows;
 }
 
 async function gmailRead(messageId, options = {}) {
@@ -700,6 +797,11 @@ async function gmailCommand(subcommand, ...args) {
       await gmailArchive(parsed.positional, { accountId: parsed.accountId || undefined });
       break;
     }
+    case 'triage': {
+      const parsed = parseGmailTriageArgs(args);
+      await gmailTriage(parsed);
+      break;
+    }
     case 'verdicts': {
       const parsed = parseGmailVerdictsArgs(args);
       printGmailVerdicts(parsed);
@@ -729,7 +831,8 @@ async function gmailCommand(subcommand, ...args) {
       console.log('  atris gmail inbox [--account <id>]       - list recent emails for a mailbox');
       console.log('  atris gmail read <id> [--account <id>]   - read specific email');
       console.log('  atris gmail archive <id> [...] [--account <id>] - archive messages (reversible, all mail keeps them)');
-      console.log('  atris gmail verdicts [--account <id>] [--limit N] - list recent archive verdicts');
+      console.log('  atris gmail triage [--account <id>] [--limit N] - record keep or archive verdicts without changing mail');
+      console.log('  atris gmail verdicts [--account <id>] [--limit N] - list recent gmail verdicts');
       console.log('  atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - send an email');
       console.log('  atris gmail voice [account] [--clear]    - edit or clear an account writing voice');
       console.log('  atris gmail connect [name]               - connect or reconnect a gmail account');
@@ -2253,6 +2356,9 @@ module.exports = {
   appendGmailVerdicts,
   readGmailVerdicts,
   printGmailVerdicts,
+  parseGmailTriageArgs,
+  gmailTriageVerdict,
+  gmailTriage,
   calendarCommand,
   twitterCommand,
   slackCommand,

package/commands/worktree.js

@@ -358,11 +358,14 @@ function statusCounts(root, {
   ignoredUnstagedFiles = new Set(),
   ignoredUntrackedFiles = new Set(),
   ignoreUntracked = null,
+  ignoreAny = null,
 } = {}) {
   if (!fs.existsSync(root)) return null;
   // -uall expands untracked directories to individual files so ignoredUntrackedFiles
   // and ignoreUntracked can match exact paths (plain porcelain collapses them to "?? dir/").
-  const expandUntracked = ignoredUntrackedFiles.size || typeof ignoreUntracked === 'function';
+  const expandUntracked = ignoredUntrackedFiles.size
+    || typeof ignoreUntracked === 'function'
+    || typeof ignoreAny === 'function';
   const statusArgs = expandUntracked ? ['status', '--porcelain', '-uall'] : ['status', '--porcelain'];
   const result = runGit(statusArgs, { cwd: root, check: false });
   if (result.status !== 0) return null;
@@ -371,6 +374,7 @@ function statusCounts(root, {
   let untracked = 0;
   for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
     const file = line.slice(3);
+    if (typeof ignoreAny === 'function' && ignoreAny(file)) continue;
     if (ignoredUnstagedFiles.has(file) && line[0] === ' ' && line[1] !== ' ') continue;
     if (line.startsWith('??')) {
       if (ignoredUntrackedFiles.has(file)) continue;
@@ -457,6 +461,16 @@ function printStatus() {
 function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task, branch: branchOverride, path: pathOverride, base: baseOverride, now = new Date() } = {}) {
   const owner = member || agent;
   if (!owner || !task) throw new Error('createAgentWorktree: owner (member/agent) and task required');
+  // Every new flight pays down completed checkout debt before adding another
+  // full repo copy. Branches and commits survive worktree removal, while real
+  // uncommitted changes remain protected by cleanupWorktrees.
+  let reapedBeforeStart = [];
+  let cachePrunedBeforeStart = [];
+  try {
+    const cleaned = cleanupWorktrees({ root, base: defaultMainlineBase(root), apply: true });
+    reapedBeforeStart = cleaned.removed;
+    cachePrunedBeforeStart = cleaned.cachePruned;
+  } catch {}
   const branch = branchOverride || branchName(owner, task, now);
   const target = path.resolve(pathOverride || defaultWorktreePath(root, owner, task, now));
   const explicitBase = Boolean(baseOverride);
@@ -489,7 +503,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     }, null, 2) + '\n',
     'utf8'
   );
-  return { path: target, branch, base: shipBase, checkoutBase, owner };
+  return { path: target, branch, base: shipBase, checkoutBase, owner, reapedBeforeStart, cachePrunedBeforeStart };
 }
 
 function startWorktree(args) {
@@ -543,6 +557,13 @@ function startWorktree(args) {
   }
   const { path: target, branch, base } = created;
 
+  if (created.reapedBeforeStart.length) {
+    console.log(`cleanup: reaped ${created.reapedBeforeStart.length} completed ${created.reapedBeforeStart.length === 1 ? 'worktree' : 'worktrees'}`);
+  }
+  if (created.cachePrunedBeforeStart.length) {
+    console.log(`cleanup: pruned ${created.cachePrunedBeforeStart.length} generated ${created.cachePrunedBeforeStart.length === 1 ? 'cache' : 'caches'}`);
+  }
+
   const counts = statusCounts(root);
   if (counts && (counts.staged || counts.unstaged || counts.untracked)) {
     console.log(`note: primary checkout is dirty staged=${counts.staged} unstaged=${counts.unstaged} untracked=${counts.untracked}`);
@@ -889,6 +910,14 @@ const PROTECTED_BRANCHES = new Set(['main', 'master']);
 // (zero commits yet), so without a grace window the janitor reaps it while
 // the engine that requested it is still booting inside.
 const WORKTREE_REAP_GRACE_MS = 60 * 60 * 1000;
+const COMPLETED_UNMERGED_REAP_MS = WORKTREE_REAP_GRACE_MS;
+const GENERATED_WORKTREE_CACHE_DIRS = [
+  '.derivedData',
+  '.next',
+  '.swiftpm',
+  '.cache/swiftpm',
+  'node_modules/.cache',
+];
 
 function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
   try {
@@ -898,15 +927,84 @@ function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
   }
 }
 
-function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false } = {}) {
+function completedAgentOutputAgeMs(worktreePath, now = Date.now()) {
+  try {
+    const output = path.join(worktreePath, '.codex-last-message.txt');
+    return now - fs.statSync(output).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+
+function canonicalPath(value) {
+  try {
+    return fs.realpathSync(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+function listActiveProcessCwds() {
+  const result = spawnSync('lsof', ['-n', '-a', '-d', 'cwd', '-F', 'n'], {
+    encoding: 'utf8',
+    maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+  });
+  if (result.status !== 0) return [];
+  return String(result.stdout || '')
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith('n'))
+    .map((line) => canonicalPath(line.slice(1)))
+    .filter(Boolean);
+}
+
+function worktreeHasActiveProcess(worktreePath, activeCwds) {
+  const resolved = canonicalPath(worktreePath);
+  const prefix = `${resolved}${path.sep}`;
+  return activeCwds.some((cwd) => {
+    const active = canonicalPath(cwd);
+    return active === resolved || active.startsWith(prefix);
+  });
+}
+
+function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
+  const candidates = [];
+  const pruned = [];
+  for (const relative of GENERATED_WORKTREE_CACHE_DIRS) {
+    const target = path.join(worktreePath, relative);
+    if (!fs.existsSync(target)) continue;
+    const ignored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
+    if (ignored.status !== 0) continue;
+    const item = { worktree: worktreePath, path: target, relative };
+    candidates.push(item);
+    if (!apply) continue;
+    try {
+      fs.rmSync(target, { recursive: true, force: true });
+      pruned.push(item);
+    } catch (error) {
+      item.error = String((error && error.message) || error);
+    }
+  }
+  return { candidates, pruned };
+}
+
+function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false, activeCwds: activeCwdsOverride } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
+  const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessCwds();
   const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
   refreshRemoteRef(root, base);
   const candidates = [];
   const kept = [];
   const removed = [];
+  const cacheCandidates = [];
+  const cachePruned = [];
+  const pruneCachesForKept = (wtPath) => {
+    if (worktreeWithinReapGrace(wtPath)) return;
+    const caches = pruneGeneratedWorktreeCaches(wtPath, { apply });
+    cacheCandidates.push(...caches.candidates);
+    cachePruned.push(...caches.pruned);
+  };
 
   for (const wt of worktrees) {
     const wtPath = path.resolve(wt.path);
@@ -927,32 +1025,72 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       kept.push({ ...item, reason: 'protected_branch' });
       continue;
     }
-    const counts = statusCounts(wt.path);
-    if (!counts) {
+    if (worktreeHasActiveProcess(wtPath, activeCwds)) {
+      kept.push({ ...item, reason: 'active_process' });
+      continue;
+    }
+    const rawCounts = statusCounts(wt.path);
+    const counts = statusCounts(wt.path, { ignoreAny: isConductorArtifact });
+    if (!rawCounts || !counts) {
       kept.push({ ...item, reason: 'missing_or_unreadable' });
       continue;
     }
     if (counts.staged || counts.unstaged || counts.untracked) {
+      pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: 'dirty', staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked });
       continue;
     }
     if (!wt.head) {
+      pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: 'missing_head' });
       continue;
     }
+    const artifactOnlyDirty = Boolean(
+      (rawCounts.staged || rawCounts.unstaged || rawCounts.untracked)
+      && !(counts.staged || counts.unstaged || counts.untracked)
+    );
     const merged = runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status === 0;
     if (!merged) {
-      kept.push({ ...item, reason: 'unmerged' });
+      const completedAgeMs = completedAgentOutputAgeMs(wtPath);
+      if (completedAgeMs === null || completedAgeMs < COMPLETED_UNMERGED_REAP_MS) {
+        pruneCachesForKept(wtPath);
+        kept.push({
+          ...item,
+          reason: completedAgeMs === null ? 'unmerged' : 'completed_unmerged_retention',
+          ...(completedAgeMs === null ? {} : { retention_hours: 1 }),
+        });
+        continue;
+      }
+      const candidate = {
+        ...item,
+        reason: 'completed_unmerged_checkout_expired',
+        branch_preserved: true,
+        artifact_only_dirty: artifactOnlyDirty,
+      };
+      candidates.push(candidate);
+      if (!apply) continue;
+      const removeArgs = ['worktree', 'remove'];
+      if (artifactOnlyDirty) removeArgs.push('--force');
+      removeArgs.push(wt.path);
+      const removedResult = runGit(removeArgs, { cwd: root, check: false });
+      if (removedResult.status === 0) {
+        removed.push(candidate);
+      } else {
+        kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
+      }
       continue;
     }
     if (worktreeWithinReapGrace(wtPath)) {
       kept.push({ ...item, reason: 'fresh_worktree_grace' });
       continue;
     }
-    const candidate = { ...item, reason: 'merged_into_base' };
+    const candidate = { ...item, reason: 'merged_into_base', artifact_only_dirty: artifactOnlyDirty };
     candidates.push(candidate);
     if (!apply) continue;
-    const removedResult = runGit(['worktree', 'remove', wt.path], { cwd: root, check: false });
+    const removeArgs = ['worktree', 'remove'];
+    if (artifactOnlyDirty) removeArgs.push('--force');
+    removeArgs.push(wt.path);
+    const removedResult = runGit(removeArgs, { cwd: root, check: false });
     if (removedResult.status === 0) {
       removed.push(candidate);
     } else {
@@ -960,7 +1098,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
     }
   }
 
-  return { apply, base, candidates, removed, kept };
+  return { apply, base, candidates, removed, kept, cacheCandidates, cachePruned };
 }
 
 function cleanup(args) {
@@ -980,6 +1118,11 @@ function cleanup(args) {
   for (const item of result.apply ? result.removed : result.candidates) {
     console.log(`${action}: ${item.path} branch=${item.branch} reason=${item.reason}`);
   }
+  const cacheAction = result.apply ? 'cache_pruned' : 'cache_candidate';
+  console.log(`${cacheAction}s: ${result.apply ? result.cachePruned.length : result.cacheCandidates.length}`);
+  for (const item of result.apply ? result.cachePruned : result.cacheCandidates) {
+    console.log(`${cacheAction}: ${item.path}`);
+  }
   console.log(`kept: ${result.kept.length}`);
   if (!result.apply && result.candidates.length) console.log('next: atris worktree cleanup --apply');
   return 0;
@@ -1010,11 +1153,12 @@ function guide() {
   console.log('   --target <ref> overrides the default landing target (default: branch atris-base, else origin default branch)');
   console.log('   recommended verify: npm run test:fast && node --test <focused files>');
   console.log('');
-  console.log('5. Clean merged worktrees:');
+  console.log('5. Cleanup is part of creation and the janitor; run it directly any time:');
   console.log('   atris worktree cleanup');
   console.log('   atris worktree cleanup --apply');
   console.log('');
   console.log('Notes: start uses the current upstream/default remote base, not dirty local HEAD.');
+  console.log('Start reaps completed checkouts first. Cleanup preserves branches and source changes, skips live work, and prunes only ignored build caches.');
   console.log('Use `atris worktree status` to see all worktrees and dirty counts.');
   return 0;
 }
@@ -1032,7 +1176,7 @@ function help() {
   console.log('  atris worktree status');
   console.log('  atris worktree guard [--allow-primary] [--allow-dirty]');
   console.log('  atris worktree prune [--apply]');
-  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]');
+  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and ignored build caches');
 }
 
 function worktreeCommand(args = []) {

package/lib/conductor-artifacts.js

@@ -7,9 +7,11 @@
 // by its own prompt file.
 const CONDUCTOR_UNTRACKED_PATTERN =
   /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|codex-watchdog\.js|codex-watchdog-[^/]+\.json|runtime-tmp(?:\/.*)?|state\/briefs\.jsonl)$/;
+const CONDUCTOR_ROOT_OUTPUT_PATTERN = /^\.codex-last-message\.txt$/;
 
 function isConductorArtifact(file) {
-  return CONDUCTOR_UNTRACKED_PATTERN.test(String(file || ''));
+  const value = String(file || '');
+  return CONDUCTOR_UNTRACKED_PATTERN.test(value) || CONDUCTOR_ROOT_OUTPUT_PATTERN.test(value);
 }
 
 // Accepts a `git status --porcelain` line ("?? .atris/fleet-prompt-BCK-1.md").

package/package.json

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