atris 3.71.2 → 3.72.0

package/atris/skills/campaigns/SKILL.md

@@ -12,7 +12,7 @@ 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 until the judge passes, a budget (cloud only) 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. A pass only counts when a second, fresh run of the judge passes right after it; a pass that does not repeat is recorded as a failure, so a flaky judge cannot end a campaign by luck.
 
 ## Size it first
 

package/bin/atris.js

@@ -533,6 +533,7 @@ function showHelpShort() {
   console.log('  atris spaceship                  Keep working for a few hours');
   console.log('  atris autopilot                  Keep working until you stop');
   console.log('  atris mission                    the one goal');
+  console.log('  atris gm                         play your team as a front office');
   console.log('');
   console.log('More: atris help --all   ·   machine list: atris help --json');
 }
@@ -606,6 +607,7 @@ function showHelpAll() {
   console.log('  who        - Show local engines and team members working, waiting, done, or stale');
   console.log('  stream     - Watch the whole team work live in one terminal');
   console.log('  team       - One team view: members, roles, engine assignments (presence for live)');
+  console.log('  gm         - Play your team as a front office: ratings, stuck jobs, league, replay, phone');
   console.log('  host       - The Host: gets to know people, makes two-yes introductions (atris member install host)');
   console.log('  watch      - Turn one sentence into an always-on background watcher');
   console.log('  ctop       - Show a process-first live agent CPU/memory view');
@@ -698,6 +700,7 @@ function showHelpAll() {
   console.log('  pull       - Pull journals + member data from cloud');
   console.log('  push       - Push workspace files to cloud');
   console.log('  sync-checkout - fetch and fast-forward a clean current branch');
+  console.log('  zen        - make this repo calm and current, keeping everything (--check to only look)');
   console.log('  cloud      - Delete cloud files not present locally (cloud clean --dry-run|--yes)');
   console.log('  live       - Keep a business brain fresh (doctor, pull, watch, push)');
   console.log('  clean-workspace <slug> - Analyze & remove junk files from a workspace (alias: cw)');
@@ -2018,7 +2021,7 @@ if (command === 'guide') {
     .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'campaign') {
   Promise.resolve(require('../commands/campaign').campaignCommand(process.argv.slice(3)))
-    .then((code) => process.exit(code || 0))
+    .then((code) => exitAfterStdoutDrain(code || 0))
     .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'who') {
   Promise.resolve(require('../commands/who').whoCommand(process.argv.slice(3)))
@@ -2305,6 +2308,9 @@ if (command === 'guide') {
 } else if (command === 'sync-checkout') {
   const code = require('../commands/sync-checkout').syncCheckoutCommand(process.argv.slice(3));
   process.exit(code);
+} else if (command === 'zen') {
+  const code = require('../commands/zen').zenCommand(process.argv.slice(3));
+  process.exit(code);
 } else if (command === 'update' || command === 'sync') {
   const args = process.argv.slice(3);
   const firstSyncArg = process.argv[3];
@@ -2971,7 +2977,7 @@ if (command === 'guide') {
     .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'gm') {
   require('../commands/gm').gmCommand(...process.argv.slice(3))
-    .then(() => process.exit(0))
+    .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'game') {
   require('../commands/game').gameCommand(process.argv.slice(3))

package/commands/autoland.js

@@ -742,6 +742,7 @@ async function runTick(root, args) {
     else console.log('autoland is off; tick did nothing.');
     return 0;
   }
+  if (args.includes('--dry-run')) return runTickPreview(root, { json, receipt });
 
   // One live tick at a time: verify re-runs can take minutes each, and a
   // second hourly cron firing into the same snapshot double-accepts,
@@ -769,6 +770,44 @@ async function runTick(root, args) {
   }
 }
 
+// `atris autoland tick --dry-run`: what the hourly pass would close, send
+// back, and check, read only. No lock, no receipt, no GitHub writes, no job
+// changes, no fetch.
+function runTickPreview(root, { json, receipt }) {
+  receipt.dry_run = true;
+  runMergedWorkClose(root, receipt, { dryRun: true });
+  // The second check's next turn, in the order it would take the jobs.
+  try {
+    const taskDb = require('../lib/task-db');
+    const workspaceRoot = taskDb.workspaceRoot(mainCheckoutRoot(root) || root);
+    const certify = require('./task').cmdCertifyVerified([], { preview: true, silent: true, workspaceRoot });
+    receipt.second_check = {
+      would_check: certify.results.filter((r) => r.action === 'would_certify').map((r) => ({ ref: r.ref, verify: r.verify })),
+      skipped: certify.results.filter((r) => r.action === 'skipped').map((r) => ({ ref: r.ref, reason: r.reason })),
+    };
+  } catch (err) {
+    receipt.second_check_error = String((err && err.message) || err).slice(0, 200);
+  }
+  if (json) {
+    console.log(JSON.stringify(receipt));
+    return 0;
+  }
+  const close = receipt.merged_close || {};
+  console.log(`autoland tick (dry run): would close ${(close.would_close || []).length} merged job${(close.would_close || []).length === 1 ? '' : 's'}, would send ${(close.would_send_back || []).length} clashing job${(close.would_send_back || []).length === 1 ? '' : 's'} back`);
+  const prLine = (row) => (row.action === 'merged_earlier'
+    ? `merged earlier, closed without counting it as a new landing: its own pull request #${row.number} merged over a day ago`
+    : `its own pull request #${row.number} merged`);
+  for (const row of close.would_close || []) console.log(`  close ${row.ref || row.id}: ${row.proof || prLine(row)}`);
+  for (const row of close.would_send_back || []) console.log(`  send back ${row.id}: pull request #${row.number} clashes`);
+  for (const line of close.merge_line || []) console.log(`  ${line}`);
+  if (receipt.merged_close_error) console.log(`  could not check merged work: ${receipt.merged_close_error}`);
+  const check = receipt.second_check || { would_check: [], skipped: [] };
+  console.log(`second check: would check ${check.would_check.length} job${check.would_check.length === 1 ? '' : 's'} next, ${check.skipped.length} skipped`);
+  for (const row of check.would_check) console.log(`  check ${row.ref}: ${row.verify}`);
+  if (receipt.second_check_error) console.log(`  could not preview the second check: ${receipt.second_check_error}`);
+  return 0;
+}
+
 function persistTickReceipt(root, receipt) {
   const runsDir = path.join(root, 'atris', 'runs');
   fs.mkdirSync(runsDir, { recursive: true });
@@ -916,6 +955,57 @@ function engineAnswerValidationLine(receipt) {
   return `graded ${graded} engine answer${graded === 1 ? '' : 's'}, scoreboard updated`;
 }
 
+// Merged work closes its jobs; clashing work goes back on the list. Until
+// 2026-10-22 this ran only inside the team wake loop, which last swept on
+// 2026-10-15, so four merged jobs waited a week. Two sources: the autoland
+// list (pull requests GitHub merged at the member's own commit, through the
+// team loop's shared five-minute pass) and git itself (lib/merged-review-close.js)
+// for jobs that left the list. dryRun reads and reports, and writes nothing.
+function runMergedWorkClose(root, receipt, { dryRun = false, now = Date.now() } = {}) {
+  const out = dryRun
+    ? { would_close: [], would_send_back: [], merge_line: [] }
+    : { closed: [], sent_back: [], merge_line: [] };
+  const closedList = dryRun ? out.would_close : out.closed;
+  const sentList = dryRun ? out.would_send_back : out.sent_back;
+  try {
+    const memberAutoland = require('../lib/member-autoland');
+    const queue = dryRun
+      ? memberAutoland.requeueDroppedAutolands({ cwd: root, now, dryRun: true })
+      : memberAutoland.sweepAfterMissionRun({ cwd: root, now });
+    for (const r of (queue && queue.results) || []) {
+      if (r.line) out.merge_line.push(r.line);
+      for (const id of r.closed || []) closedList.push({ id, how: 'pull_request', number: r.number, action: r.stale ? 'merged_earlier' : 'merged' });
+      for (const id of r.sent_back || []) sentList.push({ id, number: r.number });
+    }
+    const taskDb = require('../lib/task-db');
+    const db = taskDb.open();
+    const workspace = taskDb.workspaceRoot(mainCheckoutRoot(root) || root);
+    const tasks = taskDb.listTasks(db, { workspaceRoot: workspace, status: 'review' })
+      .filter((t) => !closedList.some((c) => c.id === t.id));
+    const scan = require('../lib/merged-review-close').closeMergedReviewJobs({ root, tasks, now, dryRun });
+    for (const row of dryRun ? scan.matched : scan.closed) closedList.push(row);
+    out.checked = scan.checked;
+  } catch (err) {
+    receipt.merged_close_error = String((err && err.message) || err).slice(0, 200);
+  }
+  receipt.merged_close = out;
+  return out;
+}
+
+function mainCheckoutRoot(root) {
+  const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout.trim()) return null;
+  return path.dirname(result.stdout.trim());
+}
+
+function mergedCloseNote(receipt) {
+  const closed = (receipt.merged_close?.closed || []).length;
+  const sent = (receipt.merged_close?.sent_back || []).length;
+  return (closed ? `, closed ${closed} merged job${closed === 1 ? '' : 's'}` : '')
+    + (sent ? `, sent ${sent} clashing job${sent === 1 ? '' : 's'} back on the list` : '')
+    + (receipt.merged_close_error ? ', could not check which jobs already merged' : '');
+}
+
 async function runTickBody(root, { json, policy, receipt, engineValidationDeps = {} }) {
 
   try {
@@ -940,7 +1030,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
   // Refresh origin once, before anything is accepted: the landing proof reads
   // origin's target, and a stale ref would call landed work unlanded.
   refreshLandingRefs(root);
-  const cliArgs = ['task', 'auto-accept-certified', '--json', '--certify-first'];
+  const cliArgs =['task', 'auto-accept-certified', '--json', '--certify-first'];
   if (policy.accept_all) cliArgs.push('--all');
   else if (policy.strict_verify === false) cliArgs.push('--no-strict-verify');
   const pendingReviewRows = readProjection(root)
@@ -1008,6 +1098,14 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     receipt.accept_error = describeAcceptKillCause(accept) || accept.stderr.slice(0, 200) || 'auto-accept output unreadable';
   }
 
+  // 2a. merged work closes its jobs and clashing work goes back on the list,
+  // every hour, whether or not a team loop is running. After the accept step,
+  // so work that can be checked and landed the normal way is landed first.
+  const mergedClose = runMergedWorkClose(root, receipt);
+  if ((mergedClose.closed || []).length + (mergedClose.sent_back || []).length > 0) {
+    try { require('./task').refreshKeptTaskList(root); } catch {}
+  }
+
   // 2b. tell the operator the moment something lands: one text, one landing
   // sentence per piece (the day-one PM sentence written at finish time),
   // capped at three with the rest counted. Off with live_updates: false.
@@ -1312,7 +1410,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     // Always print the standing backlog, and name work that cleared every
     // gate and still did not land. That is the shape of a stuck loop.
     const stuckNote = stuckBacklogNote(receipt);
-    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}${acceptedNotLandedNote(receipt)}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${engineSweepNote}${sshAgentSweepNote(receipt)}${lostRunSweepNote(receipt)}${receiptNote}`;
+    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}${acceptedNotLandedNote(receipt)}${mergedCloseNote(receipt)}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${engineSweepNote}${sshAgentSweepNote(receipt)}${lostRunSweepNote(receipt)}${receiptNote}`;
     const validationLine = engineAnswerValidationLine(receipt);
     if (validationLine) console.log(validationLine);
     console.log(gateForHuman(summary).text);
@@ -1346,6 +1444,8 @@ function showHelp() {
   console.log('  atris autoland off                 back to approving every item');
   console.log('  atris autoland digest [--send]     the daily message, now');
   console.log('  atris autoland tick [--json]       one heartbeat (what the hourly cron runs)');
+  console.log('  atris autoland tick --dry-run      what the heartbeat would close, send back,');
+  console.log('                                     and check, without changing anything');
   console.log('');
   console.log('help is always read-only: atris autoland tick --help never lands work.');
   console.log('');

package/commands/campaign.js

@@ -14,9 +14,10 @@ const { CAMPAIGN_ID, isHumanActor, validateCampaign } = require('../lib/campaign
 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 { confirmedReading, judgeRanData, judgeReading, outputTail } = require('../lib/campaign-reading');
 const { CLOUD_FEATURES, cloudLink, cloudRunStatus, runInCloud, sendPersonAction, syncCampaign, takeCampaignToken } = require('../lib/campaign-sync');
 const { campaignHome, changedProtected, checkoutTop, headCommit, planProtect, readProtect, saveProtect } = require('../lib/campaign-protect');
+const schedules = require('../lib/campaign-schedule');
 
 const JUDGE_TIMEOUT_SECONDS = 15 * 60;
 // Who pays for a campaign's engines (atris/features/campaign/api.md, Credits).
@@ -50,8 +51,17 @@ function printHelp() {
   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');
+  console.log('  atris campaign tick [--max-steps 4] [--parallel 1]   push the next campaign here that has work, one mission at a time (the overnight heartbeat runs this)');
+  console.log('  atris campaign wake                    one step for every due campaign; a wait not yet due is skipped');
+  console.log('  atris campaign keep --install|--remove [--dry-run]   a one-minute timer that runs wake (launchd or cron)');
+  console.log('  atris campaign schedule <id> --every "weekdays 09:00" [--steps 4]   a person says yes once; wake and tick');
+  console.log('        start the campaign at those times until its budget is spent. --every also takes "daily 18:30",');
+  console.log('        "mon,thu 07:00", or "30m". atris campaign schedule <id> --off removes it; no id lists every schedule');
   console.log('  atris campaign propose <id> [--count 3]   ask the owner\'s engine for the next missions');
   console.log('  atris campaign export <id> --trace [--out <file.jsonl>] [--full]   one row per mission for learning; redacted unless --full');
+  console.log('  atris campaign rsi [id] [--no-write]   distill trace rewards and lessons across campaigns');
+  console.log('        --loop [--rounds N] runs one real campaign step per cycle, rotating through open campaigns');
+  console.log('        --dry-run previews the cycles without running campaign work');
   console.log('  atris campaign sync <id>               trade events with the Atris cloud so web and iOS show it');
   console.log('        start --cloud syncs at once; run syncs before and after every step of a synced campaign;');
   console.log('        on a computer that has never seen <id>, sync pulls the whole campaign from the cloud');
@@ -79,7 +89,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 = ['--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'];
+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', '--every', '--steps'];
 
 function positionals(args) {
   const out = [];
@@ -251,7 +261,7 @@ function makeContext(args, deps) {
   const append = (campaignId, type, data, as = actor) => store.append({ campaign_id: campaignId, type, actor: as, data });
   // A campaign's own files (its judge copy, held-out data) live beside the store, outside the repo.
   const folder = deps.campaignFolder || ((id) => path.join(holdoutRoot, 'campaigns', id));
-  return { asJson, store, actor, judge, holdoutRoot, out, fail, append, forgedHuman, folder, loopDeps: deps.loopDeps, cloud: deps.cloud || {} };
+  return { asJson, store, actor, judge, holdoutRoot, out, fail, append, forgedHuman, folder, loopDeps: deps.loopDeps, keepDeps: deps.keep, cloud: deps.cloud || {} };
 }
 
 function requireCampaign(ctx, id) {
@@ -301,7 +311,21 @@ function renderShow(view) {
   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');
+  let ovrByMember = new Map();
+  try {
+    const { openCampaignStore: openStore } = require('../lib/campaign-store');
+    const { summarizeStoreRsi } = require('../lib/campaign-rsi');
+    const summary = summarizeStoreRsi(openStore(process.cwd()));
+    for (const m of summary.members || []) {
+      if (m && m.member && typeof m.overall === 'number') ovrByMember.set(m.member, m.overall);
+    }
+  } catch {}
+  const formatSeat = (s) => {
+    const ovr = ovrByMember.has(s.member) ? `${ovrByMember.get(s.member)} ovr` : '';
+    const detail = [s.role, ovr].filter(Boolean).join(' · ');
+    return detail ? `${s.member} (${detail})` : s.member;
+  };
+  row('seats', view.seats.length ? view.seats.map(formatSeat).join(', ') : 'none');
   row('missions', view.missions.length ? '' : 'none');
   for (const m of view.missions) {
     const cost = m.cost_usd === null || !paysDollars(view) ? '' : ` · ${money(m.cost_usd)}`;
@@ -502,7 +526,9 @@ function describeCloudRun(data) {
 function cmdShow(args, ctx) {
   const { view, error } = requireCampaign(ctx, positionals(args)[1]);
   if (error !== undefined) return error;
-  ctx.out(renderShow(view), { ok: true, campaign: view, next: decide(view) });
+  const schedule = schedules.readSchedule(ctx.campaignHome, view.id);
+  const text = schedule ? `${renderShow(view)}\nschedule  ${schedules.describe(schedule)}` : renderShow(view);
+  ctx.out(text, { ok: true, campaign: view, next: decide(view), schedule });
   return 0;
 }
 
@@ -524,7 +550,7 @@ async function cmdSetJudge(args, ctx) {
     return ctx.fail(`the new judge already passes (${reading.summary || 'exit 0'}). Write a judge that fails first.`, 1);
   }
   ctx.append(view.id, 'judge_set', { judge, from: view.judge });
-  ctx.append(view.id, 'judge_ran', { passed: reading.passed, summary: reading.summary || `exit ${reading.exit}`, seconds: reading.seconds }, 'judge');
+  ctx.append(view.id, 'judge_ran', judgeRanData(reading), 'judge');
   const after = getCampaign(ctx.store, view.id);
   ctx.out(`judge changed to: ${judge}\n${renderShow(after)}`, { ok: true, action: 'judge_set', campaign: after, next: decide(after) });
   return 0;
@@ -535,7 +561,9 @@ async function cmdJudge(args, ctx) {
   if (error !== undefined) return error;
   const timeout = Number(readFlag(args, '--timeout', '')) || JUDGE_TIMEOUT_SECONDS;
   if (!ctx.asJson) console.error(`running the judge: ${view.judge}`);
-  const reading = await ctx.judge(view.judge, timeout, view.id);
+  // A pass that would finish the campaign must pass a second, fresh run first.
+  const run = () => ctx.judge(view.judge, timeout, view.id);
+  const reading = view.standing ? await run() : await confirmedReading(run);
   ctx.append(view.id, 'judge_ran', judgeRanData(reading), 'judge');
   const after = getCampaign(ctx.store, view.id);
   const verdict = reading.passed ? 'passed' : 'failed';
@@ -544,6 +572,56 @@ async function cmdJudge(args, ctx) {
   return reading.passed ? 0 : 1;
 }
 
+async function cmdRsi(args, ctx) {
+  const id = positionals(args)[1] || null;
+  if (id) {
+    const { error } = requireCampaign(ctx, id);
+    if (error !== undefined) return error;
+  }
+  const {
+    formatNextCampaigns,
+    formatOvernightRsi,
+    formatRsiReport,
+    runOvernightRsi,
+    selectNextCampaigns,
+    summarizeStoreRsi,
+    writeRsiSnapshot,
+  } = require('../lib/campaign-rsi');
+  if (args.includes('--loop')) {
+    const rounds = Number(readFlag(args, '--rounds', '1'));
+    if (!Number.isSafeInteger(rounds) || rounds < 1) return ctx.fail('--rounds must be a positive whole number');
+    const res = await runOvernightRsi(process.cwd(), {
+      store: ctx.store,
+      rounds,
+      campaignId: id,
+      dryRun: args.includes('--dry-run'),
+      stepCampaign: async (campaignId, selected, prepare) => {
+        let step = null;
+        const code = await cmdLoop(['step', campaignId, ...args.slice(1)], {
+          ...ctx,
+          out: (text, data) => { step = data; },
+          fail: (error, code = 2) => { step = { ok: false, error }; return code; },
+        }, 'step', prepare);
+        // Keep receipts small: campaign state is captured by the after reading.
+        const { campaign, next, ...result } = step || {};
+        return { ...result, ok: code === 0 && result.ok !== false };
+      },
+    });
+    ctx.out(formatOvernightRsi(res), { ok: true, action: 'campaign_rsi_loop', ...res });
+    return res.ok ? 0 : 1;
+  }
+  const rsi = args.includes('--no-write')
+    ? summarizeStoreRsi(ctx.store, id)
+    : writeRsiSnapshot(process.cwd(), ctx.store, id);
+  if (args.includes('--next')) {
+    const nextList = selectNextCampaigns(ctx.store, rsi);
+    ctx.out(formatNextCampaigns(nextList), { ok: true, action: 'campaign_rsi_next', next_campaigns: nextList, rsi });
+    return 0;
+  }
+  ctx.out(formatRsiReport(rsi), { ok: true, action: 'campaign_rsi', rsi });
+  return 0;
+}
+
 // Exit 1 when a protected path changed since start, naming each one.
 function cmdGuard(args, ctx) {
   const { view, error } = requireCampaign(ctx, positionals(args)[1]);
@@ -661,7 +739,7 @@ const cmdEvent = (args, ctx) => {
   return 0;
 };
 
-async function cmdLoop(args, ctx, verb) {
+async function cmdLoop(args, ctx, verb, prepare = null) {
   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
@@ -676,9 +754,13 @@ async function cmdLoop(args, ctx, verb) {
     process.once('exit', lock.release);
   }
   try {
+    if (prepare) prepare();
     return await driveLoop(args, ctx, verb, view);
   } finally {
-    if (lock) lock.release();
+    if (lock) {
+      process.removeListener('exit', lock.release);
+      lock.release();
+    }
   }
 }
 
@@ -731,7 +813,7 @@ async function driveLoop(args, ctx, verb, view) {
     const result = await loop.step(view.id);
     const after = getCampaign(ctx.store, view.id);
     ctx.out(`${result.stop ? `stopped: ${result.reason}` : `did: ${result.did}`}\n${renderShow(after)}`, { ok: true, ...result, campaign: after, next: decide(after), sync_warnings: syncWarnings });
-    return 0;
+    return result.ok === false ? 1 : 0;
   }
   const work = readFlag(args, '--work', '');
   const pause = readFlag(args, '--break', '');
@@ -747,19 +829,189 @@ async function driveLoop(args, ctx, verb, view) {
     }
     const result = await cadence.run(view.id);
     ctx.out(`stopped after ${result.rounds} round${result.rounds === 1 ? '' : 's'}: ${result.reason}\n${renderShow(result.campaign)}`, { ok: true, ...result, next: decide(result.campaign) });
-    return 0;
+    return result.ok === false ? 1 : 0;
   }
   const maxSteps = Number(readFlag(args, '--max-steps', '')) || 20;
   const result = await loop.run(view.id, maxSteps);
   ctx.out(`stopped after ${result.steps} step${result.steps === 1 ? '' : 's'}: ${result.reason}\n${renderShow(result.campaign)}`, { ok: true, ...result, next: decide(result.campaign), sync_warnings: syncWarnings });
+  return result.ok === false ? 1 : 0;
+}
+
+// atris campaign tick: one bounded push on the next campaign in this workspace that has
+// work to do. The overnight heartbeat (atris pulse tick) calls it, so campaigns stacked
+// before bed keep moving all night: when one finishes, the next tick picks the next.
+// Skipped: done, paused, out of money, waiting on a person, or driven by another run.
+async function cmdTick(args, ctx) {
+  const { listCampaigns } = require('../lib/campaign-store');
+  const { liveHolder } = require('../lib/campaign-run-lock');
+  const now = (ctx.loopDeps && ctx.loopDeps.now) || Date.now;
+  let maxSteps = Math.max(1, Number(readFlag(args, '--max-steps', '')) || 4);
+  const skipped = [];
+  let pick = null;
+  for (const view of listCampaigns(ctx.store)) {
+    if (view.error) { skipped.push({ id: view.id, why: `unreadable: ${view.error}` }); continue; }
+    const move = decide(view);
+    if (move.action === 'none') continue;
+    // A scheduled campaign moves only when its time comes (lib/campaign-schedule.js).
+    const schedule = schedules.readSchedule(ctx.campaignHome, view.id);
+    if (schedule && !schedules.isDue(schedule, now())) { skipped.push({ id: view.id, why: `scheduled: next run ${schedules.whenText(schedule.next_at)}` }); continue; }
+    if (move.action === 'wait' && move.reason === 'open asks') { skipped.push({ id: view.id, why: `needs you: ${move.asks.length} open ask${move.asks.length === 1 ? '' : 's'}` }); continue; }
+    if (move.action === 'wait' && move.reason === 'budget') { skipped.push({ id: view.id, why: 'waiting for budget' }); continue; }
+    // A campaign sleeping until its next check is skipped, so the next one with work gets the push.
+    if (view.next_move && view.next_move.action === 'wait' && Date.now() < view.next_move.wake_at) { skipped.push({ id: view.id, why: `next check at ${new Date(view.next_move.wake_at).toISOString()}` }); continue; }
+    const holder = ctx.campaignHome ? liveHolder(ctx.campaignHome, view.id) : null;
+    if (holder) { skipped.push({ id: view.id, why: `another run drives it (pid ${holder.pid})` }); continue; }
+    if (schedule) {
+      schedules.markFired(ctx.campaignHome, view.id, schedule, now());
+      if (!readFlag(args, '--max-steps', '')) maxSteps = schedule.steps;
+    }
+    pick = view;
+    break;
+  }
+  if (!pick) {
+    const why = skipped.length ? skipped.map((s) => `${s.id}: ${s.why}`).join('; ') : 'every campaign here is done, paused, or out of money';
+    ctx.out(`nothing to advance: ${why}`, { ok: true, picked: null, skipped });
+    return 0;
+  }
+  if (!ctx.asJson) console.log(`advancing ${pick.id} (up to ${maxSteps} steps)${skipped.length ? `; skipped ${skipped.map((s) => s.id).join(', ')}` : ''}`);
+  // One mission at a time unless asked: nobody is watching overnight, and missions
+  // in one folder can write the same files.
+  const passthrough = ['--parallel', readFlag(args, '--parallel', '') || '1'];
+  for (const flag of ['--runner', '--max-ticks', '--mission-minutes']) {
+    const value = readFlag(args, flag, '');
+    if (value) passthrough.push(flag, value);
+  }
+  return cmdLoop(['run', pick.id, '--max-steps', String(maxSteps), ...passthrough, ...(ctx.asJson ? ['--json'] : [])], ctx, 'run');
+}
+
+// One step for every due campaign: a saved wait whose time has come, or work
+// with no wait saved. Finished, paused, and broke campaigns are skipped, and so
+// is a wait not yet due. Exits 0 when a step fails, so a timer keeps firing;
+// each campaign's result is in the summary.
+async function cmdWake(args, ctx) {
+  const now = (ctx.loopDeps && ctx.loopDeps.now) || Date.now;
+  const flags = args.slice(args.indexOf('wake') + 1);
+  const woke = [];
+  const skipped = [];
+  for (const view of listCampaigns(ctx.store)) {
+    if (view.error) { skipped.push({ campaign_id: view.id, reason: `cannot be read: ${view.error}` }); continue; }
+    const move = decide(view);
+    if (move.action === 'none') { skipped.push({ campaign_id: view.id, reason: move.reason }); continue; }
+    // A scheduled campaign waits for its time, then gets a whole bounded run,
+    // one mission at a time, instead of one step a minute.
+    const schedule = schedules.readSchedule(ctx.campaignHome, view.id);
+    if (schedule && !schedules.isDue(schedule, now())) {
+      skipped.push({ campaign_id: view.id, reason: `scheduled: next run ${schedules.whenText(schedule.next_at)}` });
+      continue;
+    }
+    const saved = view.next_move;
+    if (!schedule && saved && saved.action === 'wait' && now() < saved.wake_at) {
+      skipped.push({ campaign_id: view.id, reason: `next check at ${new Date(saved.wake_at).toISOString()}` });
+      continue;
+    }
+    if (schedule) schedules.markFired(ctx.campaignHome, view.id, schedule, now());
+    const loopArgs = schedule
+      ? ['run', view.id, '--max-steps', String(schedule.steps), '--parallel', '1', ...flags]
+      : ['step', view.id, ...flags];
+    let step = null;
+    let code;
+    try {
+      code = await cmdLoop(loopArgs, {
+        ...ctx,
+        out: (text, data) => { step = data; },
+        fail: (error, failCode = 2) => { step = { ok: false, error }; return failCode; },
+      }, schedule ? 'run' : 'step');
+    } catch (err) {
+      code = 1;
+      step = { ok: false, error: err.message };
+    }
+    const { campaign, next, ...result } = step || {};
+    woke.push({ campaign_id: view.id, ...result, ...(schedule ? { scheduled: true } : {}), ok: code === 0 && result.ok !== false });
+  }
+  const said = (w) => {
+    if (!w.ok) return `failed: ${w.error || w.reason}`;
+    if (w.scheduled) return `ran on schedule, ${w.steps} step${w.steps === 1 ? '' : 's'}: ${w.reason}`;
+    return w.stop ? `stopped: ${w.reason}` : `did: ${w.did}`;
+  };
+  const lines = [
+    ...woke.map((w) => `${w.campaign_id}  ${said(w)}`),
+    ...skipped.map((s) => `${s.campaign_id}  skipped: ${s.reason}`),
+  ];
+  const head = `woke ${woke.length} campaign${woke.length === 1 ? '' : 's'}, skipped ${skipped.length}`;
+  ctx.out([head, ...lines].join('\n'), { ok: true, action: 'campaign_wake', at: new Date(now()).toISOString(), woke, skipped });
+  return 0;
+}
+
+// A person's standing yes: the campaign starts on its own at set times until
+// its budget is spent. Agents may remove a schedule but never set one.
+function cmdSchedule(args, ctx) {
+  const now = (ctx.loopDeps && ctx.loopDeps.now) || Date.now;
+  const id = positionals(args)[1];
+  if (!id) {
+    const rows = listCampaigns(ctx.store).filter((view) => !view.error)
+      .map((view) => ({ view, schedule: schedules.readSchedule(ctx.campaignHome, view.id) }))
+      .filter((row) => row.schedule);
+    const text = rows.length ? rows.map((row) => `${row.view.id}  ${schedules.describe(row.schedule)}`).join('\n') : 'no campaign here has a schedule';
+    ctx.out(text, { ok: true, schedules: rows.map((row) => row.schedule) });
+    return 0;
+  }
+  const { view, error } = requireCampaign(ctx, id);
+  if (error !== undefined) return error;
+  if (args.includes('--off')) {
+    const removed = schedules.removeSchedule(ctx.campaignHome, view.id);
+    ctx.out(removed ? `${view.id} no longer runs on a schedule` : `${view.id} had no schedule`, { ok: true, removed });
+    return 0;
+  }
+  const every = readFlag(args, '--every', '');
+  if (!every) {
+    const schedule = schedules.readSchedule(ctx.campaignHome, view.id);
+    ctx.out(schedule ? `${view.id}  ${schedules.describe(schedule)}` : `${view.id} has no schedule. Set one: atris campaign schedule ${view.id} --every "weekdays 09:00"`, { ok: true, schedule });
+    return 0;
+  }
+  if (!isHumanActor(ctx.actor)) return ctx.fail('a schedule starts work with nobody watching, so only a person can set one. Ask them: atris campaign ask <id> "Run this every ...?"');
+  if (view.state === 'done') return ctx.fail(`${view.id} is done; a schedule would never run`);
+  if (noLimit(view)) return ctx.fail(`${view.id} has no budget, and a schedule runs with nobody watching. Start it with --budget, then schedule it`);
+  const parsed = schedules.parseEvery(every);
+  if (parsed.error) return ctx.fail(parsed.error);
+  const stepsFlag = readFlag(args, '--steps', '');
+  const steps = stepsFlag ? Math.floor(Number(stepsFlag)) : schedules.DEFAULT_STEPS;
+  if (!(steps >= 1)) return ctx.fail('--steps must be a whole number, 1 or more');
+  const schedule = schedules.saveSchedule(ctx.campaignHome, view.id, { every: parsed.every, rule: parsed.rule, steps, by: ctx.actor, now: now() });
+  const left = `stops on its own when the ${money(view.budget.available)} left is spent`;
+  const fires = 'atris campaign keep --install starts it on time here; the overnight heartbeat (atris pulse) also fires it';
+  ctx.out(`${view.id} runs ${schedules.describe(schedule)}. It ${left}.\n${fires}`, { ok: true, schedule });
+  return 0;
+}
+
+// A one-minute timer that runs `atris campaign wake` for this checkout.
+function cmdKeep(args, ctx) {
+  const { installKeep, planKeep, removeKeep } = require('../lib/campaign-keep');
+  const install = args.includes('--install');
+  if (install === args.includes('--remove')) return ctx.fail('say which: atris campaign keep --install|--remove [--dry-run]');
+  const keepDeps = ctx.keepDeps || {};
+  const plan = planKeep({ root: process.cwd(), home: ctx.campaignHome, atrisBin: path.resolve(__dirname, '..', 'bin', 'atris.js'), ...(keepDeps.plan || {}) });
+  const action = install ? 'keep_install' : 'keep_remove';
+  const where = plan.kind === 'launchd' ? plan.file : 'your crontab';
+  const describe = `a ${plan.kind} timer that runs every minute:\n  ${plan.command}\n  in ${plan.root}\n  at ${where}\n  log ${plan.log_path}`;
+  if (args.includes('--dry-run')) {
+    ctx.out(`would ${install ? 'install' : 'remove'} ${describe}`, { ok: true, action, dry_run: true, plan });
+    return 0;
+  }
+  const result = (install ? installKeep : removeKeep)(plan, keepDeps);
+  if (!result.ok) return ctx.fail(result.error, 1);
+  const done = install ? `installed ${describe}` : (result.removed ? `removed the timer at ${where}` : 'no timer was installed for this checkout');
+  ctx.out(done, { ok: true, action, ...result, plan });
   return 0;
 }
 
 const VERBS = {
+  wake: cmdWake, keep: cmdKeep, schedule: cmdSchedule,
   start: cmdStart, show: cmdShow, judge: cmdJudge, guard: cmdGuard, seat: cmdSeat, bet: cmdBet, budget: cmdBudget,
   pause: cmdPause, resume: cmdResume, stop: cmdStop, event: cmdEvent,
   ask: cmdAsk, answer: cmdAnswer, 'set-judge': cmdSetJudge, sync: cmdSync, 'cloud-run': cmdCloudRun,
+  rsi: cmdRsi, learn: cmdRsi,
   run: (args, ctx) => cmdLoop(args, ctx, 'run'),
+  tick: cmdTick,
   step: (args, ctx) => cmdLoop(args, ctx, 'step'),
   propose: (args, ctx) => cmdLoop(args, ctx, 'propose'),
   // atris campaign new "<goal>": the owner's engine drafts a judge that fails today (lib/campaign-new.js).