atris 3.71.0 → 3.71.2

package/atris/skills/campaigns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: campaigns
-description: "Run an Atris campaign: a long goal with a judge that fails today, a budget, and members in seats, worked by missions until the judge passes. Use when the goal takes many runs, needs several members, or must spend under a cap. Triggers on: run a campaign, long goal, big goal, keep going until it passes, campaign, judge, budget, atris campaign."
+description: "Run an Atris campaign: a long goal (hours to days) with a judge that fails today and members in seats, worked by missions until the judge passes. Use only when the path is unknown and takes many tries; a quick fix or a single mission is not a campaign. Triggers on: run a campaign, long goal, big goal, keep going until it passes, campaign, judge, budget, atris campaign."
 version: 1.0.0
 tags:
   - campaign
@@ -12,14 +12,18 @@ tags:
 
 # Campaigns
 
-A campaign is a goal plus a judge. The judge is a command that exits 0 only when the goal is met. The campaign runs missions under a budget until the judge passes, the money runs out, or a person has to decide something.
+A campaign is a goal plus a judge. The judge is a command that exits 0 only when the goal is met. The campaign runs missions until the judge passes, a budget (cloud only) runs out, or a person has to decide something.
 
-## Campaign or mission
+## Size it first
 
-- **Mission**: one member, one objective, one check. Done in a run or a few ticks.
-- **Campaign**: the goal needs many missions, more than one member, or a spending cap. A campaign decides what to do next; its missions do the work.
+Ask one question: do you already know the steps?
 
-If one `atris mission start` would finish it, use a mission.
+- **Quick fix** (minutes): you know the file and the fix. Edit it, run the tests that cover it, ship. No mission, no judge.
+- **Mission** (an hour or a few): you know what done looks like and roughly how. One `atris mission start`, or a few across members.
+- **Campaign** (hours to days): done is clear and measurable, the path is not, and it takes many tries. A campaign decides what to do next; its missions do the work.
+- **Purpose** (months to years): a standing campaign (`--standing`). Campaigns run under it (`--parent`), and each one's lessons feed the next.
+
+A campaign is a vision, not a fix. If one mission would finish it, use a mission; if you could write the diff in ten minutes, write it. Measured 2026-10-16: a 50-line fix run as a campaign took six jobs and 29 minutes.
 
 ## The five commands
 

package/atris.md

@@ -131,6 +131,7 @@ Six primitives, one sentence each:
 - **The Mission** (MISSION.md): the enduring purpose. Never ends. Sits at the top and helps members pick goals.
 - **Goals** (endgame, member goals): direction derived from the Mission. A goal points; it does not commit.
 - **A mission run** (`atris mission`): a goal that signed a contract: objective + owner + verifier + stop condition. Ends in hours or days. Any engine can tick it.
+- **A campaign** (`atris campaign`): a measurable goal with a judge that fails today, worked by many mission runs until it passes. Hours to days.
 - **Tasks** (`atris task`): the smallest provable units. Receipts, then human accept.
 - **Members** (`atris member`): the WHO. A role with memory and judgment doing one bounded, proven slice at a time.
 - **Loops** (`atris loops`): the WHEN. Clocks that never finish, only fire. Health is exit 0 on cadence.
@@ -236,6 +237,14 @@ Before picking up work, decide scope:
 - single project → route to that project's `atris/team/` and `atris task` queue
 - crosses projects → route to `atris/team/cross-project-architect/` and plan the dependency order first
 
+Then size it, before any tool runs. Ask one question: do I already know the steps?
+- **Quick fix** (minutes): you know the file and the fix. Do it, run the tests that cover it, ship. No mission, no judge.
+- **Mission** (an hour or a few): you know what done looks like and roughly how. One mission run, or a few across members (builder builds, validator checks).
+- **Campaign** (hours to days): done is clear and measurable, the path is not, and it takes many tries. `atris campaign` with a judge that fails today; its missions do the work.
+- **Purpose** (months to years): a standing campaign under the Mission. Its judge runs on a schedule, campaigns run under it, and each one's lessons and scored record feed the next. This is the self-improving loop.
+
+Never size up for show. A fix run as a campaign wastes time and inference and leaves bad data (2026-10-16: a 50-line fix run as a campaign took six jobs and 29 minutes). Sizing is judgment, not a command: `atris wish` is for imagining, not for sizing.
+
 The human is the constructor. You multiply. Handoff fidelity lives in the files, not in context.
 
 ## next

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

@@ -11,12 +11,12 @@ const path = require('path');
 const { spawn } = require('child_process');
 const { readFlag } = require('../lib/arg-parser');
 const { CAMPAIGN_ID, isHumanActor, validateCampaign } = require('../lib/campaign-schema');
-const { decide } = require('../lib/campaign-core');
+const { decide, paysDollars } = require('../lib/campaign-core');
 const { campaignDbPath, getCampaign, listCampaigns, newCampaignId, openCampaignStore } = require('../lib/campaign-store');
 const { findHoldout, moveHoldoutBack, moveHoldoutIn, scrub } = require('../lib/campaign-holdout');
 const { judgeRanData, judgeReading, outputTail } = require('../lib/campaign-reading');
 const { CLOUD_FEATURES, cloudLink, cloudRunStatus, runInCloud, sendPersonAction, syncCampaign, takeCampaignToken } = require('../lib/campaign-sync');
-const { campaignHome, changedProtected, checkoutTop, planProtect, readProtect, saveProtect } = require('../lib/campaign-protect');
+const { campaignHome, changedProtected, checkoutTop, headCommit, planProtect, readProtect, saveProtect } = require('../lib/campaign-protect');
 
 const JUDGE_TIMEOUT_SECONDS = 15 * 60;
 // Who pays for a campaign's engines (atris/features/campaign/api.md, Credits).
@@ -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 = [];
@@ -211,6 +211,13 @@ function keepJudgeScript(judge, folder) {
   return { from: file, judge: shellQuote(copy) };
 }
 
+// The commit saved on a campaign's start, or null when it started outside git.
+function savedStartCommit(store, campaignId) {
+  if (!campaignId) return null;
+  const start = store.read(campaignId).find((event) => event.type === 'campaign_started');
+  return (start && start.data && start.data.start_commit) || null;
+}
+
 function makeContext(args, deps) {
   const asJson = args.includes('--json');
   const store = deps.store || openCampaignStore(process.cwd());
@@ -220,10 +227,15 @@ function makeContext(args, deps) {
   // Held-out files live beside the campaign store, outside every checkout.
   const holdoutRoot = deps.holdoutRoot || path.dirname(store.path || campaignDbPath());
   // A campaign with a held-out file hands its path to the judge, and nothing
-  // the judge prints from it reaches the store.
-  const judge = async (command, timeout, campaignId) => {
+  // the judge prints from it reaches the store. A campaign started in a git
+  // checkout hands the judge the commit it started from. Start passes its
+  // commit in, since nothing is saved yet.
+  const judge = async (command, timeout, campaignId, startCommit = savedStartCommit(store, campaignId)) => {
     const holdout = campaignId ? findHoldout(holdoutRoot, campaignId) : null;
-    const reading = await runJudge(command, timeout, holdout ? { ...process.env, ATRIS_CAMPAIGN_HOLDOUT: holdout } : process.env);
+    const env = { ...process.env };
+    if (holdout) env.ATRIS_CAMPAIGN_HOLDOUT = holdout;
+    if (startCommit) env.ATRIS_CAMPAIGN_START_COMMIT = startCommit;
+    const reading = await runJudge(command, timeout, env);
     if (!holdout) return reading;
     return { ...reading, summary: scrub(reading.summary, holdout), output_tail: scrub(reading.output_tail, holdout) };
   };
@@ -250,6 +262,14 @@ function requireCampaign(ctx, id) {
   return { view };
 }
 
+// On a subscription the budget is still a cap, measured at API prices, so the
+// person sees how much of it is used without a dollar figure they never paid.
+function spentText(view, paid) {
+  if (paid) return `${money(view.budget.spent)} spent of ${money(view.budget.total)}`;
+  const used = view.budget.total > 0 ? Math.round((view.budget.spent / view.budget.total) * 100) : 0;
+  return `on your subscription, nothing spent · ${used}% of the budget used`;
+}
+
 function renderList(views) {
   if (!views.length) {
     return 'No campaigns yet. Start one:\n  atris campaign "<goal as a sentence>" --judge "<command that fails today>"';
@@ -259,7 +279,7 @@ function renderList(views) {
   for (const view of sorted) {
     const running = view.missions.filter((m) => m.status === 'running').length;
     lines.push(`${clip(view.title)}  (${view.id})`);
-    const spend = noLimit(view) ? '' : ` · ${money(view.budget.spent)} of ${money(view.budget.total)}`;
+    const spend = noLimit(view) ? '' : ` · ${spentText(view, paysDollars(view))}`;
     lines.push(`  ${view.state.replace(/_/g, ' ')}${spend} · ${running} mission${running === 1 ? '' : 's'} running · answer ${view.answer.confidence}`);
     lines.push(`  next: ${nextMove(view).text}`);
   }
@@ -274,14 +294,17 @@ function renderShow(view) {
   const last = view.last_judge;
   row('judge', `${view.judge}${last ? ` · last run ${last.passed ? 'passed' : 'failed'} at ${last.at}` : ' · never run'}${view.judge_due && last ? ' · due again' : ''}`);
   row('answer', `${view.answer.confidence}${view.answer.text ? `: ${view.answer.text}` : ''}`);
-  if (!noLimit(view)) row('budget', `${money(view.budget.spent)} spent of ${money(view.budget.total)} · ${money(view.budget.reserved)} reserved · ${money(view.budget.available)} left`);
+  if (!noLimit(view)) {
+    const paid = paysDollars(view);
+    row('budget', paid ? `${spentText(view, paid)} · ${money(view.budget.reserved)} reserved · ${money(view.budget.available)} left` : spentText(view, paid));
+  }
   row('owner', view.owner + (view.standing ? ' · standing (a passing judge means healthy, not done)' : ''));
   if (view.bet) row('bet', `${view.bet.text}${view.bet.wrong_if ? ` · wrong if ${view.bet.wrong_if}` : ''}`);
   if (view.parent) row('parent', view.parent);
   row('seats', view.seats.length ? view.seats.map((s) => (s.role ? `${s.member} (${s.role})` : s.member)).join(', ') : 'none');
   row('missions', view.missions.length ? '' : 'none');
   for (const m of view.missions) {
-    const cost = m.cost_usd === null ? '' : ` · ${money(m.cost_usd)}`;
+    const cost = m.cost_usd === null || !paysDollars(view) ? '' : ` · ${money(m.cost_usd)}`;
     lines.push(`  ${m.id.padEnd(22)} ${m.status.padEnd(8)} ${m.member || '-'}${m.outcome ? ` · ${m.outcome}` : ''}${cost}`);
   }
   row('asks', view.asks.length ? '' : 'none');
@@ -352,7 +375,8 @@ async function cmdStart(args, ctx) {
 
   const timeout = Number(readFlag(args, '--timeout', '')) || JUDGE_TIMEOUT_SECONDS;
   if (!ctx.asJson) console.error(`running the judge first: ${judge}`);
-  const reading = await ctx.judge(judge, timeout, id);
+  const startCommit = headCommit(process.cwd());
+  const reading = await ctx.judge(judge, timeout, id, startCommit);
   if (reading.passed && !standing) {
     moveHoldoutBack(held);
     return ctx.fail(`already done: the judge passes before any work (${reading.summary || 'exit 0'}). Write a judge that fails first.`, 1);
@@ -371,6 +395,7 @@ async function cmdStart(args, ctx) {
   if (bet && !wrongIf) startData.bet = bet;
   if (standing) startData.standing = true;
   if (basis) startData.basis = basis;
+  if (startCommit) startData.start_commit = startCommit;
   ctx.append(id, 'campaign_started', startData);
   if (bet && wrongIf) ctx.append(id, 'bet_set', { bet, wrong_if: wrongIf });
   if (parent) ctx.append(id, 'attached', { parent_id: parent });
@@ -639,6 +664,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 +710,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/commands/mission.js

@@ -6989,18 +6989,34 @@ const CLAUDE_SESSION_CONTEXT_ROTATE_TICKS = Math.max(
 // before the tick fires. Same tag-plus-text routing the task lane uses
 // (CLI-1189). An operator override is explicit: protected_lane_ack in the
 // mission metadata, set by a human, or ATRIS_ALLOW_PROTECTED_MISSION=1.
-function missionProtectedLaneHold(mission) {
+function missionProtectedLaneHold(mission, root = process.cwd()) {
   if (process.env.ATRIS_ALLOW_PROTECTED_MISSION === '1') return null;
   if (mission?.metadata?.protected_lane_ack) return null;
   const { DENIED_TAGS } = require('../lib/fleet');
   const { declaredProtectedLane, sniffedProtectedLane } = require('../lib/auto-accept-certified');
   const lane = String(mission?.lane || '').toLowerCase();
-  if (DENIED_TAGS.includes(lane)) return { pause_reason: `protected-lane-${lane}` };
   const probe = { title: mission?.objective, objective: mission?.stop_condition, metadata: mission?.metadata || {} };
-  if (declaredProtectedLane(probe)) return { pause_reason: 'protected-lane-declared' };
-  const sniffed = sniffedProtectedLane(probe);
-  if (sniffed) return { pause_reason: `protected-lane-${sniffed.lane}` };
-  return null;
+  let hold = null;
+  if (DENIED_TAGS.includes(lane)) hold = { pause_reason: `protected-lane-${lane}`, lane };
+  else if (declaredProtectedLane(probe)) hold = { pause_reason: 'protected-lane-declared', lane: 'declared' };
+  else {
+    const sniffed = sniffedProtectedLane(probe);
+    if (sniffed) hold = { pause_reason: `protected-lane-${sniffed.lane}`, lane: sniffed.lane };
+  }
+  // Inside a campaign, a person may have allowed this lane by answering the
+  // campaign's ask. Only a person's answer closes an ask, so it counts as the ack.
+  if (hold && mission?.campaign_id && campaignApprovedLane(root, mission.campaign_id, hold.lane)) return null;
+  return hold ? { pause_reason: hold.pause_reason } : null;
+}
+
+function campaignApprovedLane(root, campaignId, lane) {
+  try {
+    const { openCampaignStore } = require('../lib/campaign-store');
+    const { approvedLanes } = require('../lib/campaign-lanes');
+    return approvedLanes(openCampaignStore(root).read(campaignId)).has(lane);
+  } catch {
+    return false;
+  }
 }
 
 function runnerUsesCallerSession(runner) {
@@ -10342,7 +10358,7 @@ async function executeMissionRunTicksPhase(context) {
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
       if (effectiveMissionVerifier(mission) !== storedVerifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
-      const protectedHold = missionProtectedLaneHold(mission);
+      const protectedHold = missionProtectedLaneHold(mission, cwd);
       if (protectedHold) { pauseReason = protectedHold.pause_reason; break; }
 
       const tickIdx = Number(mission.last_tick_index || 0) + 1;

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-cadence.js

@@ -9,6 +9,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { paysDollars } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
 
 const LESSON_LINES_FOR_PLANNING = 30;
@@ -44,8 +45,14 @@ function roundSummary(before, after) {
   return { kept, failed, vetoed, spent, fresh };
 }
 
+// On a subscription the round is told without dollars, since none were paid.
+function roundTally(view, summary) {
+  return `${summary.kept} kept, ${summary.failed} failed${paysDollars(view) ? `, $${summary.spent} spent` : ''}`;
+}
+
 function reviewPrompt(view, summary, lessons) {
-  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
+  const paid = paysDollars(view);
+  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${paid && m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
   return [
     'You review one round of an Atris campaign. Reply with 2 to 6 short lessons, one per line, each starting with "- ".',
     'A lesson says what to do differently next round, in plain words. Do not repeat a lesson already listed.',
@@ -53,7 +60,7 @@ function reviewPrompt(view, summary, lessons) {
     `Campaign: ${view.title}`,
     `Judge: ${view.judge}`,
     `Judge now: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${view.last_judge.reading !== null ? ` (reading ${view.last_judge.reading})` : ''}: ${view.answer.text || ''}` : 'never run'}`,
-    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start, $${summary.spent} spent`,
+    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start${paid ? `, $${summary.spent} spent` : ''}`,
     'Missions this round:',
     missions,
     '',
@@ -88,9 +95,9 @@ function makeCadence(root, loop, options = {}, deps = {}) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     if (!fs.existsSync(file)) fs.writeFileSync(file, `# Lessons: ${after.title}\n\nWritten by the owner at each review; the next round plans from them.\n`);
     const stamp = new Date(now()).toISOString().slice(0, 16).replace('T', ' ');
-    const header = `\n## ${stamp}: ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent\n`;
+    const header = `\n## ${stamp}: ${roundTally(after, summary)}\n`;
     fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
-    return { summary, lessons: written };
+    return { summary, lessons: written, view: after };
   }
 
   async function run(id) {
@@ -111,8 +118,8 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       }
       const breakStarted = now();
       log(`round ${round}: review`);
-      const { summary, lessons } = await review(id, before);
-      log(`  ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const { summary, lessons, view: reviewed } = await review(id, before);
+      log(`  ${roundTally(reviewed, summary)}; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
       const view = getCampaign(store, id);
       last = { reason: stopped || 'work window ended', round };
       // Finished, out of money, or waiting on a person: no point in another round.

package/lib/campaign-core.js

@@ -282,6 +282,9 @@ function fold(events) {
     bet: s.bet,
     parent: s.parent,
     home: s.home,
+    // Only when the start event names one, so the shared golden views stay as
+    // pinned; no basis means the person's own engines.
+    ...(d.basis === 'atris_cloud' || d.basis === 'own_engines' ? { basis: d.basis } : {}),
     created_from: d.created_from === undefined ? null : d.created_from,
     seats: s.seats,
     state,
@@ -327,4 +330,12 @@ function decide(view) {
   return { action: 'propose', reason: 'no missions queued' };
 }
 
-module.exports = { cents, compareEvents, decide, fold };
+// Spend is real dollars only when billing is API or Atris runs the campaign on
+// its own engines (basis atris_cloud). Otherwise the work ran on the person's own
+// subscriptions: they paid nothing, and cost_usd stays as the API-price budget meter.
+function paysDollars(view) {
+  if (process.env.ATRIS_BILLING === 'api') return true;
+  return Boolean(view && view.basis === 'atris_cloud');
+}
+
+module.exports = { cents, compareEvents, decide, fold, paysDollars };

package/lib/campaign-lanes.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// Protected lanes inside a campaign. A mission that touches billing, security,
+// deploys, or customers pauses before its first tick (missionProtectedLaneHold).
+// Inside a campaign that pause becomes an ask; a person answering yes approves
+// that one lane for that one campaign. The approval lives in the campaign's own
+// event log, where only a person's answer closes an ask.
+
+const { isHumanActor } = require('./campaign-schema');
+
+const LANE_ASK_KIND = 'protected_lane';
+const YES = /^\s*(y|yes|ok|okay|approve|approved|allow|go|sure)\b/i;
+const PAUSE_LINE = /paused: protected-lane-([a-z]+)/i;
+
+// The lane a paused `atris mission run` reported, or null.
+function pausedLane(output) {
+  const match = String(output || '').match(PAUSE_LINE);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// Lanes a person approved, from a campaign's events.
+function approvedLanes(events) {
+  const asked = new Map();
+  const lanes = new Set();
+  for (const event of events || []) {
+    const data = event && event.data ? event.data : {};
+    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane) asked.set(data.ask_id, data.lane);
+    if (event.type === 'ask_answered' && asked.has(data.ask_id) && isHumanActor(event.actor) && YES.test(String(data.answer || ''))) {
+      lanes.add(asked.get(data.ask_id));
+    }
+  }
+  return lanes;
+}
+
+// True when this campaign already has an open ask for the lane, so the loop asks once.
+function laneAskOpen(events, lane) {
+  const open = new Set();
+  for (const event of events || []) {
+    const data = event && event.data ? event.data : {};
+    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane === lane) open.add(data.ask_id);
+    if (event.type === 'ask_answered') open.delete(data.ask_id);
+  }
+  return open.size > 0;
+}
+
+function laneQuestion(lane, member, objective) {
+  const what = String(objective || '').replace(/\s+/g, ' ').trim();
+  const short = what.length > 140 ? `${what.slice(0, 139)}…` : what;
+  return `${member}'s mission touches ${lane}: "${short}". Missions that touch ${lane} wait for you. Let this campaign work on ${lane}? Answer yes to allow it.`;
+}
+
+module.exports = { LANE_ASK_KIND, pausedLane, approvedLanes, laneAskOpen, laneQuestion };

package/lib/campaign-loop.js

@@ -12,6 +12,7 @@ const { decide } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
 const { defaultReserve, reconcileCampaign } = require('./campaign-missions');
 const { judgeRanData, latestJudgeOutput } = require('./campaign-reading');
+const { LANE_ASK_KIND, pausedLane, laneAskOpen, laneQuestion } = require('./campaign-lanes');
 
 const TERMINAL = new Set(['stopped', 'complete']);
 
@@ -86,17 +87,37 @@ async function askOwner(root, view, prompt) {
 }
 
 // Run one atris command and resolve with its exit code and output.
+// A live step an engine prints while a mission runs: "<member> <hh:mm>  <what it is doing>".
+const ACTIVITY_LINE = /^\s*[a-z0-9][a-z0-9-]*\s+\d{1,2}:\d{2}\s{2,}\S/i;
+
 function runCli(args, { cwd, env = process.env, onLine = null } = {}) {
   return new Promise((resolve) => {
     const child = spawn(process.execPath, [CLI, ...args], { cwd, env: { ...env, ATRIS_SKIP_UPDATE_CHECK: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
     let out = '';
     let err = '';
-    child.stdout.on('data', (chunk) => {
-      out += chunk;
-      if (onLine) String(chunk).split('\n').filter(Boolean).forEach(onLine);
+    // Whole lines only: a chunk can end mid-line. Live engine steps arrive on
+    // stderr (member-progress reportProgress), so both streams are read.
+    const reader = () => {
+      let partial = '';
+      return {
+        push(chunk) {
+          if (!onLine) return;
+          const lines = (partial + String(chunk)).split('\n');
+          partial = lines.pop();
+          lines.filter(Boolean).forEach(onLine);
+        },
+        end() { if (onLine && partial) onLine(partial); },
+      };
+    };
+    const stdout = reader();
+    const stderr = reader();
+    child.stdout.on('data', (chunk) => { out += chunk; stdout.push(chunk); });
+    child.stderr.on('data', (chunk) => { err += chunk; stderr.push(chunk); });
+    child.on('close', (code) => {
+      stdout.end();
+      stderr.end();
+      resolve({ code, out, err });
     });
-    child.stderr.on('data', (chunk) => { err += chunk; });
-    child.on('close', (code) => resolve({ code, out, err }));
   });
 }
 
@@ -105,10 +126,13 @@ 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;
-  const cli = deps.cli || ((args) => runCli(args, { cwd: root }));
+  const cli = deps.cli || ((args, extra = {}) => runCli(args, { cwd: root, ...extra }));
   const judge = deps.judge;
 
   const view = (id) => getCampaign(store, id);
@@ -155,7 +179,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();
@@ -164,8 +189,22 @@ function makeLoop(root, options = {}, deps = {}) {
       return { mission_id: work.mission_id, started: false };
     }
     log(`  ${work.mission_id} started for ${work.member}: ${work.objective}`);
-    const ran = await cli(['mission', 'run', work.mission_id, '--max-ticks', String(maxTicks), '--complete-on-pass']);
+    // The engine's live steps ("researcher 06:47  editing stable.mjs") pass through to
+    // the campaign's own output, so a screen watching the run can show the work.
+    const ran = await cli(['mission', 'run', work.mission_id, '--max-ticks', String(maxTicks), '--complete-on-pass'], { onLine: (line) => { if (ACTIVITY_LINE.test(line)) log(`    ${line.trim()}`); } });
     const after = view(id).missions.find((m) => m.id === work.mission_id);
+    // A mission in a protected lane (billing, security, deploy, customer) pauses
+    // before its first tick. Ask a person once per lane instead of failing quietly.
+    const lane = after && after.status !== 'ended' ? pausedLane(`${ran.out || ''}\n${ran.err || ''}`) : null;
+    if (lane) {
+      if (!laneAskOpen(store.read(id), lane)) {
+        const askId = `a-${crypto.randomBytes(3).toString('hex')}`;
+        append(id, 'ask_opened', { ask_id: askId, question: laneQuestion(lane, work.member, work.objective), mission_id: work.mission_id, kind: LANE_ASK_KIND, lane }, current.owner);
+      }
+      await cli(['mission', 'stop', work.mission_id, '--reason', `campaign loop: waiting for a person to allow the ${lane} lane`]);
+      log(`  ${work.mission_id} needs you: it touches ${lane}`);
+      return { mission_id: work.mission_id, started: true, outcome: null, needs: lane };
+    }
     if (after && after.status !== 'ended') {
       // The run stopped without finishing (tick cap, error): close it so its
       // reserve comes back and its cost is counted.
@@ -239,4 +278,4 @@ function makeLoop(root, options = {}, deps = {}) {
   return { step, run, propose };
 }
 
-module.exports = { askOwner, makeLoop, parseProposals, proposalPrompt };
+module.exports = { ACTIVITY_LINE, askOwner, makeLoop, parseProposals, proposalPrompt, runCli };

package/lib/campaign-protect.js

@@ -29,6 +29,12 @@ function protectFile(home, campaignId) {
   return path.join(home, 'campaigns', campaignId, 'protect.json');
 }
 
+// The commit a checkout sits on, or null outside git or before the first commit.
+function headCommit(root) {
+  const head = git(root, ['rev-parse', 'HEAD']);
+  return head.ok ? head.out : null;
+}
+
 // The commit and checkout-relative paths to save, or an error in plain words.
 function planProtect(root, paths) {
   const topDir = checkoutTop(root);
@@ -72,4 +78,4 @@ function changedProtected(root, saved) {
   return { changed: [...new Set(changed)].sort() };
 }
 
-module.exports = { campaignHome, changedProtected, checkoutTop, planProtect, protectFile, readProtect, saveProtect };
+module.exports = { campaignHome, changedProtected, checkoutTop, headCommit, planProtect, protectFile, readProtect, saveProtect };

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.2",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {