atris 3.57.0 → 3.57.1

package/commands/integrations.js

@@ -6,7 +6,7 @@
  *   atris gmail read <id> [--account <id>]   - Read specific email
  *   atris gmail archive <id> [...] [--account <id>] - Archive messages
  *   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 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
@@ -42,7 +42,7 @@ 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_VERDICTS_USAGE = 'usage: atris gmail verdicts [--summary] [--account <id>] [--limit N]';
 const GMAIL_BULK_DOMAINS = [
   'campaign-archive.com',
   'constantcontact.com',
@@ -70,6 +70,7 @@ function appendGmailVerdicts(verdicts, options = {}) {
     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');
 }
@@ -84,24 +85,56 @@ 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);
+    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;
@@ -127,9 +160,14 @@ function parseGmailTriageArgs(args = []) {
 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 {
@@ -138,7 +176,7 @@ function parseGmailVerdictsArgs(args = []) {
     }
     i += 1;
   }
-  return { account, limit };
+  return { account, limit, summary };
 }
 
 function gmailAccountStatePath() {
@@ -378,25 +416,27 @@ function gmailMessageHeaderText(message = {}) {
   return lines.join('\n').toLowerCase();
 }
 
-function gmailTriageVerdict(message = {}) {
+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)) {
-    return 'archive';
+    result = { verdict: 'archive', reason: 'noreply sender' };
   }
 
   const domain = from.match(/@([a-z0-9.-]+)/i)?.[1] || '';
-  if (GMAIL_BULK_DOMAINS.some((bulkDomain) => domain === bulkDomain || domain.endsWith(`.${bulkDomain}`))) {
-    return 'archive';
+  if (!result && GMAIL_BULK_DOMAINS.some((bulkDomain) => domain === bulkDomain || domain.endsWith(`.${bulkDomain}`))) {
+    result = { verdict: 'archive', reason: 'bulk mail domain' };
   }
 
   const headers = gmailMessageHeaderText(message);
-  if (/(?:^|\n)(?:list-id|list-unsubscribe|mailing-list|x-campaign-id|x-mailing-list)\s*:/i.test(headers)
+  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)) {
-    return 'archive';
+    || /\bunsubscribe\b/i.test(headers))) {
+    result = { verdict: 'archive', reason: 'list or unsubscribe headers' };
   }
 
-  return 'keep';
+  if (!result) result = { verdict: 'keep', reason: 'personal sender' };
+  return options.details ? result : result.verdict;
 }
 
 async function gmailTriage(options = {}) {
@@ -404,14 +444,18 @@ async function gmailTriage(options = {}) {
   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)'),
-  }));
+  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;
@@ -832,7 +876,7 @@ async function gmailCommand(subcommand, ...args) {
       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 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 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');

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.57.0",
+  "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 });
+});