atris 3.71.1 → 3.71.3

package/commands/pulse.js

@@ -53,6 +53,9 @@ Options:
   --cadence "<cron>"     Cron cadence for install
   --days <n>             Auto-expire installed heartbeat after n days
   --hours <n>            Auto-expire installed heartbeat after n hours
+  --no-keep-awake        Install without holding the Mac awake for the window (macOS)
+  --no-autopilot         install/tick: never fall back to autopilot (only campaigns and due missions)
+  --no-campaigns         tick: skip pushing campaigns (atris campaign tick)
   --model <id>           Runner model alias/id for installed heartbeat
   --runner-profile <n>   Runner profile for installed heartbeat (e.g. atris-fast)
   --runner-bin <path>    Runner binary for installed heartbeat
@@ -128,9 +131,43 @@ function runAutopilotTick(root, { timeoutMs = 600000 } = {}) {
   };
 }
 
-// The full heartbeat composition: continue a due mission, else author+pursue a
-// new goal via autopilot. This is the /loop skill's logic, encoded for OS cron.
-function runEngine(root, { noClaude = false, autopilotFallback = true, timeoutMs = 600000 } = {}) {
+// Campaigns first: one bounded push on the next campaign here that has work
+// (atris campaign tick). A campaign mission can outlast a mission tick, so it gets
+// up to 50 minutes; the campaign run lock keeps two drivers off one campaign.
+const CAMPAIGN_TICK_MS = 50 * 60 * 1000;
+function runCampaignEngine(root, { timeoutMs = CAMPAIGN_TICK_MS } = {}) {
+  const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
+  const result = spawnSync(process.execPath, [cliPath, 'campaign', 'tick', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1' },
+  });
+  let payload = null;
+  try {
+    payload = JSON.parse(result.stdout || '{}');
+  } catch {}
+  const idle = Boolean(payload && payload.picked === null);
+  return {
+    actor: 'campaign_tick',
+    ok: result.status === 0,
+    reason: idle ? 'no_campaign_work' : (payload && payload.reason) || (result.status === 0 ? 'advanced' : 'error'),
+    idle,
+    status: result.status,
+    payload,
+    stdout: String(result.stdout || '').slice(-2000),
+    stderr: String(result.stderr || '').slice(-2000),
+  };
+}
+
+// The full heartbeat composition: push a campaign that has work, else continue a
+// due mission, else author+pursue a new goal via autopilot. This is the /loop
+// skill's logic, encoded for OS cron.
+function runEngine(root, { noClaude = false, autopilotFallback = true, campaigns = true, timeoutMs = 600000 } = {}) {
+  if (campaigns && !noClaude) {
+    const campaign = runCampaignEngine(root);
+    if (!campaign.idle) return campaign;
+  }
   const mission = runMissionEngine(root, { noClaude, timeoutMs });
   if (pulse.shouldFallbackToAutopilot({ missionReason: mission.reason, autopilotFallback, noClaude })) {
     const ap = runAutopilotTick(root, { timeoutMs });
@@ -284,7 +321,7 @@ function tickCommand(args, root = process.cwd()) {
     // filesystem snapshot when git is absent.
     const isRepo = fs.existsSync(path.join(root, '.git'));
     const before = isRepo ? gitSnapshot(root) : pulse.fsSnapshot(root);
-    engine = runEngine(root, { noClaude, autopilotFallback: !hasFlag(args, '--no-autopilot') });
+    engine = runEngine(root, { noClaude, autopilotFallback: !hasFlag(args, '--no-autopilot'), campaigns: !hasFlag(args, '--no-campaigns') });
     const after = isRepo ? gitSnapshot(root) : pulse.fsSnapshot(root);
     // This tick's ACTUAL contribution: files it newly dirtied, or a new commit.
     // Pre-existing dirt is excluded so reward isn't re-credited every tick.
@@ -315,7 +352,9 @@ function tickCommand(args, root = process.cwd()) {
     const changedTail = committed
       ? ' - committed'
       : (changedFiles.length ? ` - ${changedFiles.length} file(s) changed` : '');
-    const what = engine.actor === 'autopilot'
+    const what = engine.actor === 'campaign_tick'
+      ? `campaign ${(engine.payload && engine.payload.campaign && engine.payload.campaign.id) || ''} ${engine.reason}${changedTail}`.replace(/\s+/g, ' ')
+      : engine.actor === 'autopilot'
       ? `autopilot authored/advanced a goal${changedTail}`
       : engine.reason === 'no_due_mission'
         ? 'no due mission; heartbeat alive (no-op)'
@@ -677,6 +716,8 @@ function installCommand(args, root = process.cwd(), options = {}) {
     pathDirs,
     launchLabel: label,
     launchPlistPath: plistPath,
+    // Baked into every tick: a night of campaigns only, no invented goals.
+    tickFlags: ['--no-autopilot', '--no-campaigns'].filter((flag) => hasFlag(args, flag)),
   });
   fs.writeFileSync(scriptPath, script, { mode: 0o755 });
 
@@ -695,6 +736,10 @@ function installCommand(args, root = process.cwd(), options = {}) {
   const apply = commandSpawn('launchctl', ['bootstrap', `gui/${uid}`, plistPath], { encoding: 'utf8', timeout: 10000 });
   const expiryBreadcrumbCleared = apply.status === 0 && clearPulseExpiryBreadcrumb(root);
   const cadenceMapping = pulse.launchIntervalFromCadence({ cron });
+  // Tests pass their own spawnSync and never get a real caffeinate unless they ask.
+  const wantsKeepAwake = apply.status === 0 && process.platform === 'darwin' && !hasFlag(args, '--no-keep-awake')
+    && (!options.spawnSync || options.holdKeepAwake);
+  const keepAwake = wantsKeepAwake ? (options.holdKeepAwake || holdKeepAwake)(slot.stateHome, expiry.seconds) : null;
 
   const out = {
     ok: apply.status === 0,
@@ -718,6 +763,7 @@ function installCommand(args, root = process.cwd(), options = {}) {
     runner_bin: runnerBin || null,
     runner_template_configured: Boolean(runnerCommandTemplate),
     expiry_breadcrumb_cleared: expiryBreadcrumbCleared,
+    keep_awake: keepAwake,
   };
   if (!asJson) {
     if (apply.status === 0) {
@@ -728,6 +774,7 @@ function installCommand(args, root = process.cwd(), options = {}) {
         `script: ${scriptPath}`,
         cadenceMapping.fallback ? `cadence '${cron}' is not directly mappable; using 3600 seconds.` : '',
         `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
+        ...(keepAwake ? [`keeps this Mac awake until then (lid open); atris pulse uninstall lets it sleep.`] : []),
       ].filter(Boolean).join('\n') + '\n');
     } else {
       writeOutput(`pulse install failed to bootstrap ${label}: ${apply.stderr || apply.status}\nplist: ${plistPath}\n`);
@@ -736,6 +783,40 @@ function installCommand(args, root = process.cwd(), options = {}) {
   return emit(out, asJson);
 }
 
+// The heartbeat only ticks while the Mac is awake. On macOS an overnight install
+// holds a no-idle-sleep assertion (caffeinate -i) for exactly the heartbeat's
+// window, so a Mac on its own power settings does not sleep through the night.
+// Closing the lid still sleeps. Uninstall lets it go. --no-keep-awake skips it.
+function keepAwakeFile(stateHome) {
+  return path.join(stateHome, 'keep-awake.pid');
+}
+
+function releaseKeepAwake(stateHome) {
+  const file = keepAwakeFile(stateHome);
+  let pid = 0;
+  try { pid = Number(fs.readFileSync(file, 'utf8').trim()); } catch { return false; }
+  fs.rmSync(file, { force: true });
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    const name = spawnSync('ps', ['-p', String(pid), '-o', 'comm='], { encoding: 'utf8', timeout: 5000 }).stdout.trim();
+    if (!/caffeinate$/.test(name)) return false;
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function holdKeepAwake(stateHome, seconds) {
+  releaseKeepAwake(stateHome);
+  const { spawn } = require('child_process');
+  const child = spawn('caffeinate', ['-i', '-t', String(Math.max(60, Math.floor(seconds)))], { detached: true, stdio: 'ignore' });
+  child.unref();
+  fs.mkdirSync(stateHome, { recursive: true });
+  fs.writeFileSync(keepAwakeFile(stateHome), `${child.pid}\n`);
+  return { pid: child.pid, seconds: Math.floor(seconds) };
+}
+
 function uninstallCommand(args, root = process.cwd(), options = {}) {
   const asJson = wantsJson(args);
   const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
@@ -745,6 +826,7 @@ function uninstallCommand(args, root = process.cwd(), options = {}) {
   const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
   const uid = options.uid != null ? options.uid : process.getuid();
   commandSpawn('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8', timeout: 10000 });
+  const keepAwakeReleased = (options.releaseKeepAwake || releaseKeepAwake)(slot.stateHome || slot.activeStateHome);
   const plistHad = fs.existsSync(plistPath);
   fs.rmSync(plistPath, { force: true });
   const existing = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
@@ -757,6 +839,7 @@ function uninstallCommand(args, root = process.cwd(), options = {}) {
     ok: apply.status === 0,
     action: 'pulse_uninstall',
     removed: plistHad || had,
+    keep_awake_released: keepAwakeReleased,
     label,
     plist_path: plistPath,
     removed_legacy_crontab: had,
@@ -818,5 +901,6 @@ module.exports = {
   pulseExpiryBreadcrumbPath,
   installCommand,
   runCommand,
+  uninstallCommand,
   refreshOrbPolicyLessons,
 };

package/commands/worktree.js

@@ -16,6 +16,9 @@ const close = require('./close');
 // parallel landings that each carry a copy always clash.
 const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', '.atris/state/tasks.projection.json'];
 const COMMAND_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+// Push also runs local hooks. Backend startup and regression checks alone can
+// exceed the short network-only allowance used by fetch and discovery.
+const GIT_PUSH_TIMEOUT_MS = 5 * 60 * 1000;
 const GIT_OID_PATTERN = /^[0-9a-f]{40,64}$/;
 const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -37,13 +40,15 @@ function gitNetworkEnvironment(source = process.env, cwd = process.cwd()) {
 // A killed network call leaves stderr empty; name the timeout instead.
 function gitFailureDetail(result) {
   if (result && result.error && result.error.code === 'ETIMEDOUT') return 'timed out';
-  return String((result && (result.stderr || result.stdout)) || '').trim();
+  return [result && result.stdout, result && result.stderr]
+    .map(output => String(output || '').trim()).filter(Boolean).join('\n');
 }
 
 function runGit(args, { cwd = process.cwd(), check = true, timeout } = {}) {
   const network = ['fetch', 'push', 'ls-remote'].includes(args[0]);
   // Only network calls need the SSH probe; local calls skip its extra git spawn.
-  const options = { cwd, encoding: 'utf8', timeout: timeout ?? (network ? 30000 : undefined),
+  const defaultTimeout = args[0] === 'push' ? GIT_PUSH_TIMEOUT_MS : network ? 30000 : undefined;
+  const options = { cwd, encoding: 'utf8', timeout: timeout ?? defaultTimeout,
     killSignal: 'SIGKILL', env: network ? gitNetworkEnvironment(process.env, cwd) : undefined };
   let result = spawnSync('git', args, options);
   // Linked checkouts share config. A concurrent start must not silently lose
@@ -1118,6 +1123,23 @@ function shipWorktree(args) {
         if (/already merged/i.test(`${merged.stdout}${merged.stderr}`)) {
           throw new Error(`gh pr merge reported the PR was already merged (stale PR reused): ${(merged.stdout || merged.stderr).trim()}`);
         }
+        // A merge queue accepts the request before merging. Deleting its head
+        // here closes the PR and cancels that request, so confirm the outcome.
+        const confirmation = spawnSync('gh', ['pr', 'view', mergeRef, '--json', 'state,mergedAt'], { cwd: root, encoding: 'utf8' });
+        if (confirmation.status !== 0) {
+          throw new Error('could not confirm the merge; the source branch was kept');
+        }
+        let state;
+        try { state = JSON.parse(confirmation.stdout); } catch {
+          throw new Error('could not read the merge result; the source branch was kept');
+        }
+        if (state.state === 'OPEN' && !state.mergedAt) {
+          console.log('merge: pending; kept the source branch while required checks finish');
+          return 0;
+        }
+        if (state.state !== 'MERGED' || !state.mergedAt) {
+          throw new Error('the change was not merged; the source branch was kept');
+        }
         console.log('merge: merged');
         const deleted = runGit(['push', 'origin', '--delete', branch], { cwd: root, check: false });
         if (deleted.status === 0) {

package/lib/campaign-cadence.js

@@ -9,7 +9,9 @@
 
 const fs = require('fs');
 const path = require('path');
+const { paysDollars } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
+const { readingKey } = require('./campaign-loop');
 
 const LESSON_LINES_FOR_PLANNING = 30;
 
@@ -25,16 +27,35 @@ function lessonsPath(root, campaignId) {
   return path.join(root, 'atris', 'campaigns', campaignId, 'lessons.md');
 }
 
-// The newest lessons, for the planner.
-function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+function globalLessonsPath(root) {
+  return path.join(root, 'atris', 'campaigns', 'lessons.md');
+}
+
+function parseBulletLines(filePath) {
   try {
-    const text = fs.readFileSync(lessonsPath(root, campaignId), 'utf8');
-    return text.split('\n').filter((line) => line.trim().startsWith('- ')).slice(-lines).join('\n');
+    const text = fs.readFileSync(filePath, 'utf8');
+    return text.split('\n').filter((line) => line.trim().startsWith('- '));
   } catch {
-    return '';
+    return [];
   }
 }
 
+// The newest lessons for the planner: local campaign lessons plus deduplicated
+// cross-campaign RSI lessons so every new campaign inherits earlier lessons.
+function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+  const local = parseBulletLines(lessonsPath(root, campaignId));
+  const global = parseBulletLines(globalLessonsPath(root));
+  const seen = new Set();
+  const merged = [];
+  for (const line of [...local, ...global]) {
+    const key = line.trim().toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(line);
+  }
+  return merged.slice(-lines).join('\n');
+}
+
 function roundSummary(before, after) {
   const fresh = after.missions.filter((m) => !before.missions.some((b) => b.id === m.id && b.status === m.status));
   const kept = fresh.filter((m) => m.status === 'ended' && m.outcome === 'kept').length;
@@ -44,8 +65,20 @@ function roundSummary(before, after) {
   return { kept, failed, vetoed, spent, fresh };
 }
 
+// Nothing finished and the check reads the same: there is nothing to learn.
+function quietRound(before, after, summary) {
+  const key = (v) => (v.last_judge ? readingKey(v.last_judge.passed, v.last_judge.reading, v.answer.text) : null);
+  return !summary.fresh.some((m) => m.status === 'ended' || m.status === 'vetoed') && key(before) === key(after);
+}
+
+// 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 +86,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,
     '',
@@ -75,9 +108,10 @@ function makeCadence(root, loop, options = {}, deps = {}) {
   async function review(id, before) {
     const after = getCampaign(store, id);
     const summary = roundSummary(before, after);
+    const quiet = quietRound(before, after, summary);
     const lessons = readLessons(root, id, 200);
     let written = [];
-    if (ask) {
+    if (ask && !quiet) {
       const answer = await ask(root, after, reviewPrompt(after, summary, lessons));
       // A lesson already on file is not written twice.
       const known = new Set(lessons.split('\n').map((line) => line.trim().toLowerCase()));
@@ -88,9 +122,11 @@ 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`;
-    fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
-    return { summary, lessons: written };
+    const header = `\n## ${stamp}: ${roundTally(after, summary)}\n`;
+    // A quiet round is noted as plain text, so the planner never reads it as a lesson.
+    const body = quiet ? ['(no review written this round: nothing ended and the reading held)'] : (written.length ? written : ['- (no review written this round)']);
+    fs.appendFileSync(file, `${header}${body.join('\n')}\n`);
+    return { summary, lessons: written, view: after, quiet };
   }
 
   async function run(id) {
@@ -111,8 +147,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, quiet } = await review(id, before);
+      log(quiet ? '  nothing new this round; no review' : `  ${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

@@ -60,7 +60,35 @@ function newMission(id) {
 }
 
 // Returns the folded view, or { error } when the events must be refused.
+// A judge reading can carry a saved wait: nothing to do until wake_at, then
+// check the judge again. It rides as extra data on judge_ran so a reader that
+// predates it still folds the campaign. Anything new (a mission, an answer, a
+// new judge, more money, a resume) ends the wait.
+const WAIT_ENDS = new Set(['mission_proposed', 'mission_claimed', 'mission_started', 'mission_ended', 'judge_set', 'ask_answered', 'resumed', 'budget_added']);
+
+function savedWait(data) {
+  const w = data.wait;
+  if (data.passed || !w || !Number.isFinite(w.wake_at) || !(w.wait_ms > 0)) return null;
+  return { wake_at: w.wake_at, wait_ms: w.wait_ms };
+}
+
 function fold(events) {
+  return foldEvents(events);
+}
+
+// Internal consumers can project selected canonical prefix counts in the same
+// traversal. The synchronous projector is trusted and read-only; only its
+// result is retained, so callers need not keep every full historical view.
+function foldWithPrefixes(events, prefixLengths, project = (view) => view) {
+  const requested = new Set(prefixLengths.filter((n) => Number.isSafeInteger(n) && n >= 1));
+  const prefixes = new Map();
+  const view = foldEvents(events, (state, start, owner, count) => {
+    if (requested.has(count)) prefixes.set(count, project(renderView(state, start, owner), count));
+  });
+  return view.error ? view : { view, prefixes };
+}
+
+function foldEvents(events, visit) {
   if (!Array.isArray(events)) return { error: 'invalid_event' };
   for (const event of events) {
     if (!validateEvent(event).ok) return { error: 'invalid_event' };
@@ -94,9 +122,12 @@ function fold(events) {
     asks: new Map(),
     judgeRuns: [],
     lastEndedPos: -1,
+    wait: null,
     judgeSetPos: -1,
     judge: start.data.judge,
     lastJudgePos: -1,
+    // Jobs that did real work and ended since the last reading, waiting on it.
+    awaitingReading: [],
     warnings: [],
   };
   const d = start.data;
@@ -113,6 +144,7 @@ function fold(events) {
   const sequence = [start, ...ordered.filter((e) => e !== start)];
   sequence.forEach((event, pos) => {
     const data = event.data;
+    if (WAIT_ENDS.has(event.type)) s.wait = null;
     switch (event.type) {
       case 'campaign_started':
         if (event !== start) warn(event, 'duplicate_start');
@@ -129,6 +161,7 @@ function fold(events) {
         } else {
           s.judge = data.judge;
           s.judgeSetPos = pos;
+          s.awaitingReading = [];
         }
         break;
       case 'attached':
@@ -181,6 +214,8 @@ function fold(events) {
         const m = mission(data.mission_id);
         m.status = 'ended';
         m.outcome = data.outcome;
+        if (data.outcome === 'fault' && typeof data.reason === 'string') m.reason = data.reason;
+        if (m.steps > 0 && data.outcome !== 'kept' && data.outcome !== 'fault') s.awaitingReading.push(m);
         m.costCents = cents(data.cost_usd);
         s.spentCents += m.costCents;
         s.reservations.delete(data.mission_id);
@@ -207,6 +242,11 @@ function fold(events) {
           at: event.at,
         });
         s.lastJudgePos = pos;
+        s.wait = savedWait(data);
+        // A job that worked but stopped short is credited when the very next
+        // reading passes: its work is what moved the check.
+        if (data.passed) for (const m of s.awaitingReading) m.credited = true;
+        s.awaitingReading = [];
         if (data.passed && !d.standing && !s.finished) s.finished = 'judge_passed';
         break;
       case 'ask_opened':
@@ -236,8 +276,14 @@ function fold(events) {
       default:
         break;
     }
+    if (visit) visit(s, start, owner, pos + 1);
   });
 
+  return renderView(s, start, owner);
+}
+
+function renderView(s, start, owner) {
+  const d = start.data;
   const missions = [...s.missions.values()];
   let state;
   let stopReason = null;
@@ -279,11 +325,14 @@ function fold(events) {
     judge: s.judge,
     owner,
     standing: d.standing === true,
-    bet: s.bet,
+    bet: s.bet ? { ...s.bet } : null,
     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,
+    seats: s.seats.map((seat) => ({ ...seat })),
     state,
     stop_reason: stopReason,
     answer: { text: latest ? latest.summary : null, confidence },
@@ -293,7 +342,9 @@ function fold(events) {
       reserved: dollars(reservedCents),
       available: dollars(s.totalCents - s.spentCents - reservedCents),
     },
-    asks: [...s.asks.values()],
+    asks: [...s.asks.values()].map((ask) => ({ ...ask })),
+    // Only while a wait is saved, so the shared golden views stay as pinned.
+    ...(s.wait ? { next_move: { action: 'wait', reason: 'waiting on the world', ...s.wait } } : {}),
     missions: missions.map((m) => ({
       id: m.id,
       member: m.member,
@@ -304,11 +355,13 @@ function fold(events) {
       steps: m.steps,
       kept: m.kept,
       reverted: m.reverted,
+      ...(m.reason ? { reason: m.reason } : {}),
+      ...(m.credited ? { credited: true } : {}),
     })),
     judge_runs: runs.length,
     judge_due: runs.length === 0 || Math.max(s.lastEndedPos, s.judgeSetPos) > s.lastJudgePos,
     last_judge: latest ? { passed: latest.passed, reading: latest.reading, at: latest.at } : null,
-    warnings: s.warnings,
+    warnings: s.warnings.map((warning) => ({ ...warning })),
   };
 }
 
@@ -316,9 +369,13 @@ function decide(view) {
   if (view.state === 'done') return { action: 'none', reason: 'finished' };
   if (view.state === 'out_of_budget') return { action: 'none', reason: 'budget spent' };
   if (view.state === 'paused') return { action: 'none', reason: 'paused' };
-  if (view.asks.length > 0) return { action: 'wait', reason: 'open asks', asks: view.asks.map((a) => a.id) };
+  // An open ask holds only the mission it names. When every claimed mission is
+  // held, the campaign waits for the person; an ask that names no mission holds nothing.
+  const held = new Set(view.asks.map((a) => a.mission_id).filter(Boolean));
+  const queued = view.missions.filter((m) => m.status === 'claimed');
+  const claimed = queued.filter((m) => !held.has(m.id));
+  if (queued.length > 0 && claimed.length === 0) return { action: 'wait', reason: 'open asks', asks: view.asks.map((a) => a.id) };
   if (view.judge_due) return { action: 'run_judge' };
-  const claimed = view.missions.filter((m) => m.status === 'claimed');
   const available = cents(view.budget.available);
   const fits = claimed.find((m) => cents(m.estimate_usd || 0) <= available);
   if (fits) return { action: 'start_mission', mission_id: fits.id };
@@ -327,4 +384,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, foldWithPrefixes, paysDollars };

package/lib/campaign-keep.js

@@ -0,0 +1,91 @@
+// atris campaign keep: a one-minute timer that runs `atris campaign wake`,
+// so a campaign's promise to check again holds while no terminal is open
+// (atris/features/campaign/promise.md). launchd on macOS, cron elsewhere.
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MARKER = 'ATRIS_CAMPAIGN_WAKE';
+
+function xml(text) {
+  return String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+function shellQuote(text) {
+  return `'${String(text).replace(/'/g, `'\\''`)}'`;
+}
+
+// One timer per checkout: the label and marker carry a short hash of its root.
+function planKeep({ root, home, platform = process.platform, homeDir = os.homedir(), nodeBin = 'node', atrisBin, envPath = process.env.PATH || '' }) {
+  const slot = crypto.createHash('sha256').update(root).digest('hex').slice(0, 8);
+  // node by name on the saved PATH, so upgrading node does not break the timer.
+  const command = ['/usr/bin/env', nodeBin, atrisBin, 'campaign', 'wake', '--json'];
+  const logPath = path.join(home, 'campaign-wake.log');
+  const base = { root, slot, log_path: logPath, command: command.join(' '), every_seconds: 60 };
+  if (platform === 'darwin') {
+    const label = `ai.atris.campaign-wake.${slot}`;
+    const file = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+    const contents = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>${command.map((part) => `<string>${xml(part)}</string>`).join('')}</array>
+  <key>WorkingDirectory</key><string>${xml(root)}</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${xml(envPath)}</string><key>ATRIS_SKIP_UPDATE_CHECK</key><string>1</string></dict>
+  <key>StartInterval</key><integer>60</integer>
+  <key>StandardOutPath</key><string>${xml(logPath)}</string>
+  <key>StandardErrorPath</key><string>${xml(logPath)}</string>
+</dict>
+</plist>
+`;
+    return { ...base, kind: 'launchd', label, file, contents };
+  }
+  const marker = `${MARKER}_${slot}`;
+  const line = `* * * * * cd ${shellQuote(root)} && PATH=${shellQuote(envPath)} ATRIS_SKIP_UPDATE_CHECK=1 ${command.map(shellQuote).join(' ')} >> ${shellQuote(logPath)} 2>&1 # ${marker}`;
+  return { ...base, kind: 'cron', marker, crontab_line: line };
+}
+
+function withoutMarker(crontab, marker) {
+  return String(crontab || '').split('\n').filter((l) => l.trim() && !l.includes(marker)).join('\n');
+}
+
+// Replaces any timer this checkout already has. Returns { ok, error? }.
+function installKeep(plan, { spawn = spawnSync, uid = process.getuid && process.getuid() } = {}) {
+  fs.mkdirSync(path.dirname(plan.log_path), { recursive: true });
+  if (plan.kind === 'launchd') {
+    fs.mkdirSync(path.dirname(plan.file), { recursive: true });
+    fs.writeFileSync(plan.file, plan.contents, 'utf8');
+    spawn('launchctl', ['bootout', `gui/${uid}/${plan.label}`], { encoding: 'utf8', timeout: 10000 });
+    const r = spawn('launchctl', ['bootstrap', `gui/${uid}`, plan.file], { encoding: 'utf8', timeout: 10000 });
+    return r.status === 0 ? { ok: true } : { ok: false, error: `launchctl bootstrap failed: ${String(r.stderr || r.stdout || '').trim()}` };
+  }
+  const existing = spawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  const kept = withoutMarker(existing.status === 0 ? existing.stdout : '', plan.marker);
+  const r = spawn('crontab', ['-'], { input: `${kept ? `${kept}\n` : ''}${plan.crontab_line}\n`, encoding: 'utf8', timeout: 10000 });
+  return r.status === 0 ? { ok: true } : { ok: false, error: `crontab failed: ${String(r.stderr || r.stdout || '').trim()}` };
+}
+
+function removeKeep(plan, { spawn = spawnSync, uid = process.getuid && process.getuid() } = {}) {
+  if (plan.kind === 'launchd') {
+    spawn('launchctl', ['bootout', `gui/${uid}/${plan.label}`], { encoding: 'utf8', timeout: 10000 });
+    const had = fs.existsSync(plan.file);
+    if (had) fs.unlinkSync(plan.file);
+    return { ok: true, removed: had };
+  }
+  const existing = spawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  const prior = existing.status === 0 ? String(existing.stdout || '') : '';
+  if (!prior.includes(plan.marker)) return { ok: true, removed: false };
+  const kept = withoutMarker(prior, plan.marker);
+  const r = spawn('crontab', ['-'], { input: kept ? `${kept}\n` : '', encoding: 'utf8', timeout: 10000 });
+  return r.status === 0 ? { ok: true, removed: true } : { ok: false, error: `crontab failed: ${String(r.stderr || r.stdout || '').trim()}` };
+}
+
+module.exports = { MARKER, installKeep, planKeep, removeKeep };