atris 3.71.0 → 3.71.1

package/bin/atris.js

@@ -3003,7 +3003,12 @@ if (command === 'guide') {
     const mailbox = extractGmailMailboxAccount(raw);
     // Mailbox --account <id> is a selector, not the workspace opt-in.
     // Scratch folders refuse every gmail verb the same way as slack/inbox.
-    const gate = requireAccountBound(mailbox.args.filter((arg) => arg !== '--account'));
+    // Read verbs also run from a project folder (atris/, no business.json).
+    const GMAIL_READ_VERBS = new Set(['inbox', 'list', 'read', 'triage', 'verdicts', 'accounts']);
+    const gate = requireAccountBound(
+      mailbox.args.filter((arg) => arg !== '--account'),
+      { read: GMAIL_READ_VERBS.has(mailbox.args[0]) },
+    );
     if (!gate.ok) {
       process.exit(refuseAccountGlobal());
       return;
@@ -3042,7 +3047,12 @@ if (command === 'guide') {
     const account = extractGmailMailboxAccount(raw);
     // Account --account <id> is a selector, not the workspace opt-in.
     // Scratch folders refuse every slack verb the same way as gmail/inbox.
-    const gate = requireAccountBound(account.args.filter((arg) => arg !== '--account'));
+    // Read verbs also run from a project folder (atris/, no business.json).
+    const SLACK_READ_VERBS = new Set(['channels', 'list', 'dms', 'messages', 'read', 'search']);
+    const gate = requireAccountBound(
+      account.args.filter((arg) => arg !== '--account'),
+      { read: SLACK_READ_VERBS.has(account.args[0]) },
+    );
     if (!gate.ok) {
       process.exit(refuseAccountGlobal());
       return;

package/commands/campaign.js

@@ -46,7 +46,7 @@ function printHelp() {
   console.log('  atris campaign answer <id> <ask-id> "<answer>"     a person answers; agents cannot');
   console.log('  atris campaign pause|resume|stop <id>');
   console.log('  atris campaign event <id> <type> [--data \'<json>\']   append any event by hand');
-  console.log('  atris campaign run <id> [--parallel 3] [--max-steps 20] [--max-ticks 3] [--runner auto]');
+  console.log('  atris campaign run <id> [--parallel 3] [--max-steps 20] [--max-ticks 3] [--mission-minutes 40] [--runner auto]');
   console.log('        the campaign runs itself: proposes missions, runs them at once, judges, repeats until done, broke, or needing you');
   console.log('        add --work 50m --break 10m [--rounds N] to work in rounds; each break judges and writes lessons the next round plans from');
   console.log('  atris campaign step <id>               one step of that loop');
@@ -79,7 +79,7 @@ const NO_LIMIT_BUDGET = 1e9;
 const noLimit = (view) => view.budget.total >= NO_LIMIT_BUDGET;
 
 // The flags this command understands, so positional words are what is left.
-const VALUE_FLAGS = ['--basis', '--work', '--break', '--rounds', '--mission', '--parallel', '--max-steps', '--max-ticks', '--runner', '--count', '--judge', '--budget', '--owner', '--seat', '--bet', '--wrong-if', '--parent', '--id', '--role', '--add', '--data', '--timeout', '--as', '--holdout', '--protect'];
+const VALUE_FLAGS = ['--mission-minutes', '--basis', '--work', '--break', '--rounds', '--mission', '--parallel', '--max-steps', '--max-ticks', '--runner', '--count', '--judge', '--budget', '--owner', '--seat', '--bet', '--wrong-if', '--parent', '--id', '--role', '--add', '--data', '--timeout', '--as', '--holdout', '--protect'];
 
 function positionals(args) {
   const out = [];
@@ -639,6 +639,25 @@ const cmdEvent = (args, ctx) => {
 async function cmdLoop(args, ctx, verb) {
   const { view, error } = requireCampaign(ctx, positionals(args)[1]);
   if (error !== undefined) return error;
+  // One driver per campaign: a second loop would plan and start missions
+  // against the same budget and files (lib/campaign-run-lock.js).
+  let lock = null;
+  if (ctx.store.path && ctx.campaignHome) {
+    lock = require('../lib/campaign-run-lock').acquireRunLock(ctx.campaignHome, view.id);
+    if (!lock.ok) {
+      const holder = lock.holder || {};
+      return ctx.fail(`another run is driving ${view.id} (pid ${holder.pid || '?'} in ${holder.cwd || '?'} since ${holder.started_at || '?'}); wait for it to stop or stop that process`, 1);
+    }
+    process.once('exit', lock.release);
+  }
+  try {
+    return await driveLoop(args, ctx, verb, view);
+  } finally {
+    if (lock) lock.release();
+  }
+}
+
+async function driveLoop(args, ctx, verb, view) {
   const { makeLoop } = require('../lib/campaign-loop');
   // A synced campaign trades events around every step. Failures warn and the
   // loop runs on offline; a refusal (403, 409) stops syncing for this run
@@ -666,6 +685,7 @@ async function cmdLoop(args, ctx, verb) {
   const loop = makeLoop(process.cwd(), {
     parallel: readFlag(args, '--parallel', '') || readFlag(args, '--count', ''),
     maxTicks: readFlag(args, '--max-ticks', ''),
+    missionMinutes: readFlag(args, '--mission-minutes', ''),
     runner: readFlag(args, '--runner', ''),
     actor: ctx.actor,
   }, {

package/commands/integrations.js

@@ -7,7 +7,7 @@
  *   atris gmail archive <id> [...] [--account <id>] - Archive messages
  *   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 send <to> <subject> <body...> --approved [--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
  *   atris gmail accounts                     - List connected Gmail accounts and the active account
@@ -41,7 +41,7 @@ const { sleepSync } = require('../lib/sleep-sync');
 const CALENDAR_CACHE_PATH = path.join(stateHome(), '.atris', 'calendar-events-cache.json');
 const GMAIL_CONNECT_POLL_MS = 3000;
 const GMAIL_CONNECT_TIMEOUT_MS = 3 * 60 * 1000;
-const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>]';
+const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> --approved [--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 [--summary] [--account <id>] [--limit N]';
@@ -560,10 +560,15 @@ async function gmailArchive(messageIds, options = {}) {
 function parseGmailSendArgs(args = []) {
   let accountId = null;
   let bodyFile = null;
+  let approved = false;
   const positional = [];
 
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
+    if (arg === '--approved' || arg === '--confirm-approved') {
+      approved = true;
+      continue;
+    }
     if (arg === '--account' || arg === '--body-file') {
       const value = String(args[i + 1] || '').trim();
       if (!value || value.startsWith('--')) {
@@ -596,10 +601,17 @@ function parseGmailSendArgs(args = []) {
     }
   }
 
-  return { to, subject, body, accountId };
+  return { to, subject, body, accountId, approved };
 }
 
 async function gmailSend(to, subject, body, options = {}) {
+  // Approval is checked before any token lookup or network call so an
+  // unapproved send can never reach the server.
+  if (!options.approved) {
+    console.error('Refusing to send without --approved after the exact recipient, subject, and body are confirmed.');
+    console.error(GMAIL_SEND_USAGE);
+    process.exit(2);
+  }
   const token = await getAuthToken();
   const accountId = resolveGmailAccountId(options.accountId);
   const accounts = await fetchGmailAccounts(token);
@@ -864,7 +876,7 @@ async function gmailCommand(subcommand, ...args) {
     }
     case 'send': {
       const parsed = parseGmailSendArgs(args);
-      await gmailSend(parsed.to, parsed.subject, parsed.body, { accountId: parsed.accountId || undefined });
+      await gmailSend(parsed.to, parsed.subject, parsed.body, { accountId: parsed.accountId || undefined, approved: parsed.approved });
       break;
     }
     case 'voice': {
@@ -888,7 +900,7 @@ async function gmailCommand(subcommand, ...args) {
       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 [--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 send <to> <subject> <body...> --approved [--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');
       console.log('  atris gmail accounts                     - list connected gmail accounts and the active account');

package/lib/account-bound.js

@@ -20,6 +20,14 @@ function isProvisionedAgentWorkspace(cwd = process.cwd()) {
   return fs.existsSync(path.join(root, '.atris', 'agent-token.json'));
 }
 
+// A Desktop project folder carries an atris/ directory but no business.json.
+// It is a real workspace, not a scratch folder, so account reads may run
+// there. Writes (send, dm, archive, connect) still need the business binding.
+function isProjectWorkspace(cwd = process.cwd()) {
+  const root = path.resolve(cwd);
+  return fs.existsSync(path.join(root, 'atris'));
+}
+
 function isHelpArg(arg) {
   return arg === '--help' || arg === '-h' || arg === 'help';
 }
@@ -33,6 +41,8 @@ function looksLikeBusinessSlug(token) {
 /**
  * Account-scoped verbs dump live CRM/cloud state. Outside a bound business
  * workspace they must opt in with --account. Help always passes.
+ * Pass { read: true } for read-only verbs: a project folder with atris/ (no
+ * business.json) then counts as bound. Writes never get that relaxation.
  * Returns { ok, args } where args has --account stripped when continuing.
  */
 function requireAccountBound(args = [], options = {}) {
@@ -44,6 +54,9 @@ function requireAccountBound(args = [], options = {}) {
   if (isBoundBusinessWorkspace(cwd) || isProvisionedAgentWorkspace(cwd)) {
     return { ok: true, args: list.filter((arg) => arg !== '--account'), bound: true };
   }
+  if (options.read === true && isProjectWorkspace(cwd)) {
+    return { ok: true, args: list.filter((arg) => arg !== '--account'), bound: true, project: true };
+  }
   if (list.includes('--account')) {
     return { ok: true, args: list.filter((arg) => arg !== '--account'), account: true };
   }

package/lib/campaign-loop.js

@@ -105,6 +105,9 @@ function makeLoop(root, options = {}, deps = {}) {
   const log = deps.log || ((line) => console.log(line));
   const parallel = Math.max(1, Number(options.parallel) || 3);
   const maxTicks = Math.max(1, Number(options.maxTicks) || 3);
+  // Every mission gets an explicit time limit. Without one, a number in the
+  // objective ("437 tests, 475s") was read as the mission's time budget.
+  const missionMinutes = Math.max(1, Number(options.missionMinutes) || 40);
   const runner = options.runner || 'auto';
   const actor = options.actor || 'mission-lead';
   const ask = deps.ask || askOwner;
@@ -155,7 +158,8 @@ function makeLoop(root, options = {}, deps = {}) {
     const reserve = work.estimate_usd || defaultReserve(current);
     const started = await cli([
       'mission', 'start', work.objective, '--mission-id', work.mission_id, '--owner', work.member,
-      '--runner', runner, '--verify', work.verify || current.judge, '--campaign', id, '--reserve', String(reserve), '--json',
+      '--runner', runner, '--verify', work.verify || current.judge, '--campaign', id, '--reserve', String(reserve),
+      '--max-wall', String(missionMinutes * 60), '--json',
     ]);
     if (started.code !== 0) {
       const why = (started.out + started.err).trim().split('\n').pop();

package/lib/campaign-run-lock.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// One driver per campaign on a computer. Two `campaign run` loops on the same
+// campaign each planned and started missions, so they raced for the same
+// budget and edited the same files (2026-10-15, cmp-suite-3min). The lock is
+// a file beside the store naming the process that holds it; a lock whose
+// process is gone is stale and is taken over.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function lockPath(home, campaignId) {
+  return path.join(home, 'campaigns', campaignId, 'run.lock');
+}
+
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+function readHolder(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Returns { ok: true, release } or { ok: false, holder } when a live run holds it.
+function acquireRunLock(home, campaignId, { pid = process.pid, host = os.hostname(), cwd = process.cwd(), isAlive = alive } = {}) {
+  const file = lockPath(home, campaignId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const mine = { pid, host, cwd, started_at: new Date().toISOString() };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      fs.writeFileSync(file, `${JSON.stringify(mine)}\n`, { flag: 'wx' });
+      const release = () => {
+        const holder = readHolder(file);
+        if (holder && holder.pid === pid && holder.host === host) fs.rmSync(file, { force: true });
+      };
+      return { ok: true, release };
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    const holder = readHolder(file);
+    if (holder && holder.host === host && isAlive(holder.pid)) return { ok: false, holder };
+    if (holder && holder.host !== host) return { ok: false, holder };
+    fs.rmSync(file, { force: true });
+  }
+  return { ok: false, holder: readHolder(file) };
+}
+
+module.exports = { acquireRunLock, lockPath };

package/package.json

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