atris 3.56.3 → 3.57.1

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 [--summary] [--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_VERDICTS_USAGE = 'usage: atris gmail verdicts [--account <id>] [--limit N]';
+const GMAIL_TRIAGE_USAGE = 'usage: atris gmail triage [--account <id>] [--limit N]';
+const GMAIL_VERDICTS_USAGE = 'usage: atris gmail verdicts [--summary] [--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,10 +66,11 @@ 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 } : {}),
+    ...(typeof row.reason === 'string' && row.reason ? { reason: row.reason } : {}),
   }));
   fs.appendFileSync(filePath, `${lines.join('\n')}\n`, 'utf8');
 }
@@ -72,35 +85,89 @@ function readGmailVerdicts(options = {}) {
     throw error;
   }
   const account = String(options.account || '').trim();
-  const limit = Number.isInteger(options.limit) ? options.limit : 20;
-  return lines.reduce((rows, line) => {
+  const limit = options.limit === null ? null : (Number.isInteger(options.limit) ? options.limit : 20);
+  const rows = lines.reduce((matches, line) => {
     try {
       const row = JSON.parse(line);
-      if (!account || row.account === account) rows.push(row);
+      if (!account || row.account === account) matches.push(row);
     } catch {}
-    return rows;
-  }, []).reverse().slice(0, limit);
+    return matches;
+  }, []).reverse();
+  return limit === null ? rows : rows.slice(0, limit);
+}
+
+function summarizeGmailVerdicts(rows = []) {
+  const groups = new Map();
+  for (const row of rows) {
+    const date = String(row.ts || '').slice(0, 10);
+    const account = String(row.account || '');
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+    const key = `${date}\n${account}`;
+    const summary = groups.get(key) || { date, account, keep: 0, archive: 0 };
+    summary[row.verdict === 'keep' ? 'keep' : 'archive'] += 1;
+    groups.set(key, summary);
+  }
+  return [...groups.values()].sort((left, right) => (
+    right.date.localeCompare(left.date) || left.account.localeCompare(right.account)
+  ));
 }
 
 function printGmailVerdicts(options = {}) {
-  const rows = readGmailVerdicts(options);
+  const rows = readGmailVerdicts(options.summary ? { ...options, limit: null } : options);
+  if (options.summary) {
+    const summaries = summarizeGmailVerdicts(rows);
+    if (!summaries.length) {
+      console.log('no gmail verdicts found.');
+      return summaries;
+    }
+    for (const row of summaries) {
+      console.log(`${row.date} account ${row.account}, keep ${row.keep}, archive ${row.archive}`);
+    }
+    return summaries;
+  }
   if (!rows.length) {
     console.log('no gmail verdicts found.');
     return rows;
   }
   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(', ')}` : ''}`);
+    const details = [
+      row.reason && `reason ${row.reason}`,
+      row.from && `from ${row.from}`,
+      row.subject && `subject ${row.subject}`,
+    ].filter(Boolean);
+    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;
+  let summary = false;
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     const value = String(args[i + 1] || '').trim();
+    if (arg === '--summary') {
+      summary = true;
+      continue;
+    }
     if (arg === '--account' && value && !value.startsWith('--')) account = value;
     else if (arg === '--limit' && /^\d+$/.test(value) && Number(value) > 0) limit = Number(value);
     else {
@@ -109,7 +176,7 @@ function parseGmailVerdictsArgs(args = []) {
     }
     i += 1;
   }
-  return { account, limit };
+  return { account, limit, summary };
 }
 
 function gmailAccountStatePath() {
@@ -278,8 +345,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 +368,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 +393,75 @@ 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 = {}, options = {}) {
+  const from = String(message.from || message.sender || '').toLowerCase();
+  let result;
+  if (/(?:^|[^a-z0-9])(?:no[-_.]?reply|do[-_.]?not[-_.]?reply)(?:[^a-z0-9]|$)/i.test(from)) {
+    result = { verdict: 'archive', reason: 'noreply sender' };
+  }
+
+  const domain = from.match(/@([a-z0-9.-]+)/i)?.[1] || '';
+  if (!result && GMAIL_BULK_DOMAINS.some((bulkDomain) => domain === bulkDomain || domain.endsWith(`.${bulkDomain}`))) {
+    result = { verdict: 'archive', reason: 'bulk mail domain' };
+  }
+
+  const headers = gmailMessageHeaderText(message);
+  if (!result && (/(?:^|\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))) {
+    result = { verdict: 'archive', reason: 'list or unsubscribe headers' };
+  }
+
+  if (!result) result = { verdict: 'keep', reason: 'personal sender' };
+  return options.details ? result : result.verdict;
+}
+
+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) => {
+    const { verdict, reason } = gmailTriageVerdict(message, { details: true });
+    return {
+      ts,
+      account: accountId,
+      verdict,
+      reason,
+      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 +841,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 +875,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 [--summary] [--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 +2400,9 @@ module.exports = {
   appendGmailVerdicts,
   readGmailVerdicts,
   printGmailVerdicts,
+  parseGmailTriageArgs,
+  gmailTriageVerdict,
+  gmailTriage,
   calendarCommand,
   twitterCommand,
   slackCommand,

package/commands/mission.js

@@ -9934,6 +9934,15 @@ async function executeMissionRunTicksPhase(context) {
       mission = resolveMission(mission.id, cwd) || mission;
       const remainingBudgetSeconds = missionFullBudgetRemainingSeconds(mission);
       const explicitExit = ['complete', 'stopped', 'paused'].includes(String(mission.status || ''));
+      if (!pauseReason
+        && detachedDriverLifecycle
+        && mission.always_on
+        && missionSpendsFullBudget(mission)
+        && remainingBudgetSeconds <= 0
+        && !explicitExit
+        && !controller.signal.aborted) {
+        pauseReason = 'budget-exhausted';
+      }
       const healthyCycleBoundary = !pauseReason || pauseReason === 'max-ticks-reached';
       const keepDetachedFullBudgetDriverAlive = Boolean(
         detachedDriverLifecycle

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.1",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -14,6 +14,7 @@
     "commands/",
     "decks/",
     "scripts/outbound-artifact-gate.js",
+    "scripts/member-operate.mjs",
     "scripts/agent_worktree.py",
     "scripts/det/",
     "utils/",

package/scripts/member-operate.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// member-operate: the one executed slice of a member alive tick.
+//
+// Contract (lib/member-alive.js runMemberOperateScript):
+//   node scripts/member-operate.mjs <member> --json --max-wall <60..1800>
+//     --execute --confirm-autonomy-policy [--agent claude] [--model X] [--no-prime]
+// stdout: final JSON only (last line wins). stderr: live progress, prefixed
+// with ATRIS_MEMBER_OPERATE_PROGRESS\t so the alive loop can stream phases.
+//
+// This script is a dispatcher, not an engine. It delegates to
+// `atris member run <member>`, which resumes the member's active mission or
+// chooses one bounded useful task, and the mission itself carries its runner
+// (codex_goal, claude, atris2, ...). Swapping engines is mission/member
+// config, never an edit here.
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const PROGRESS_PREFIX = 'ATRIS_MEMBER_OPERATE_PROGRESS\t';
+
+function progress(payload) {
+  process.stderr.write(`${PROGRESS_PREFIX}${JSON.stringify(payload)}\n`);
+}
+
+function readFlag(args, name, fallback = '') {
+  const index = args.indexOf(name);
+  if (index === -1 || index === args.length - 1) return fallback;
+  return args[index + 1];
+}
+
+function finish(result) {
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  process.exit(result.ok === false ? 1 : 0);
+}
+
+function collectJsonSignals(text) {
+  // member run / mission run print JSON payloads along the way; harvest the
+  // fields the alive loop cares about without depending on exact shapes.
+  const signals = { receipt_path: null, needs_user: false, summary: null };
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{')) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.receipt_path) signals.receipt_path = parsed.receipt_path;
+      if (parsed.mission?.receipt_path) signals.receipt_path = parsed.mission.receipt_path;
+      if (parsed.needs_user === true) signals.needs_user = true;
+      const landing = parsed.result?.landing || parsed.landing || null;
+      if (landing?.changed) signals.summary = landing.changed;
+      else if (parsed.summary) signals.summary = parsed.summary;
+    } catch {
+      // Partial or non-JSON line; keep streaming.
+    }
+  }
+  return signals;
+}
+
+const argv = process.argv.slice(2);
+const member = argv[0] && !argv[0].startsWith('--') ? argv[0] : '';
+const args = argv.slice(1);
+
+if (!member) {
+  finish({ ok: false, reason: 'member_required', executed: false });
+}
+
+const execute = args.includes('--execute');
+const confirmed = args.includes('--confirm-autonomy-policy');
+if (!execute || !confirmed) {
+  finish({ ok: true, reason: 'operate_dry_run', member, executed: false });
+}
+
+const maxWall = Math.max(60, Math.min(1800, Number(readFlag(args, '--max-wall', '900')) || 900));
+const agent = String(readFlag(args, '--agent', '')).trim().toLowerCase();
+const model = String(readFlag(args, '--model', '')).trim();
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const atrisBin = process.env.ATRIS_BIN || path.join(scriptDir, '..', 'bin', 'atris.js');
+if (!fs.existsSync(atrisBin)) {
+  finish({ ok: false, reason: 'atris_bin_not_found', member, executed: false });
+}
+
+const runArgs = [atrisBin, 'member', 'run', member, '--json', '--max-wall', String(maxWall)];
+if (agent === 'claude') runArgs.push('--runner', 'claude');
+if (model) runArgs.push('--model', model);
+
+progress({ kind: 'phase', text: `Dispatching one bounded ${member} slice (wall cap ${maxWall}s).` });
+
+const child = spawn(process.execPath, runArgs, {
+  cwd: process.cwd(),
+  env: process.env,
+  stdio: ['ignore', 'pipe', 'pipe'],
+});
+
+let output = '';
+const forward = (chunk) => {
+  const text = chunk.toString();
+  output += text;
+  // Keep stdout clean for the final JSON; the human-visible stream is stderr.
+  process.stderr.write(text);
+};
+child.stdout.on('data', forward);
+child.stderr.on('data', forward);
+
+const wallTimer = setTimeout(() => {
+  progress({ kind: 'phase', text: `Wall cap ${maxWall}s reached; stopping the slice.` });
+  child.kill('SIGTERM');
+  setTimeout(() => child.kill('SIGKILL'), 10000).unref();
+}, maxWall * 1000);
+
+child.on('close', (code) => {
+  clearTimeout(wallTimer);
+  const signals = collectJsonSignals(output);
+  const ok = code === 0;
+  finish({
+    ok,
+    reason: ok ? 'operate_complete' : 'operate_failed',
+    member,
+    executed: true,
+    exit_code: code,
+    max_wall_seconds: maxWall,
+    needs_user: signals.needs_user,
+    receipt_path: signals.receipt_path,
+    summary: signals.summary,
+  });
+});
+
+child.on('error', (error) => {
+  clearTimeout(wallTimer);
+  finish({ ok: false, reason: `operate_spawn_failed: ${error.message}`, member, executed: true });
+});