atris 3.71.3 → 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)');
@@ -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).
@@ -53,6 +54,9 @@ function printHelp() {
   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');
@@ -85,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 = [];
@@ -522,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;
 }
 
@@ -555,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';
@@ -821,12 +829,12 @@ 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 0;
+  return result.ok === false ? 1 : 0;
 }
 
 // atris campaign tick: one bounded push on the next campaign in this workspace that has
@@ -836,19 +844,27 @@ async function driveLoop(args, ctx, verb, view) {
 async function cmdTick(args, ctx) {
   const { listCampaigns } = require('../lib/campaign-store');
   const { liveHolder } = require('../lib/campaign-run-lock');
-  const maxSteps = Math.max(1, Number(readFlag(args, '--max-steps', '')) || 4);
+  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;
   }
@@ -881,28 +897,44 @@ async function cmdWake(args, ctx) {
     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 (saved && saved.action === 'wait' && now() < saved.wake_at) {
+    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(['step', view.id, ...flags], {
+      code = await cmdLoop(loopArgs, {
         ...ctx,
         out: (text, data) => { step = data; },
         fail: (error, failCode = 2) => { step = { ok: false, error }; return failCode; },
-      }, 'step');
+      }, 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, ok: code === 0 && result.ok !== false });
+    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}  ${w.ok ? (w.stop ? `stopped: ${w.reason}` : `did: ${w.did}`) : `failed: ${w.error || w.reason}`}`),
+    ...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}`;
@@ -910,6 +942,47 @@ async function cmdWake(args, ctx) {
   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');
@@ -932,7 +1005,7 @@ function cmdKeep(args, ctx) {
 }
 
 const VERBS = {
-  wake: cmdWake, keep: cmdKeep,
+  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,

package/commands/clean.js

@@ -634,6 +634,42 @@ function findStalePages(cwd, atrisDir) {
   return stalePages;
 }
 
+/**
+ * When a source last changed. A checkout or rebase touches mtimes without
+ * changing content, so a file git holds unchanged counts from its last commit.
+ */
+function contentChangedAt(sourcePath, mtime) {
+  const dir = path.dirname(sourcePath);
+  const name = path.basename(sourcePath);
+  const status = spawnSync('git', ['status', '--porcelain', '--', name], { cwd: dir, encoding: 'utf8' });
+  if (status.status !== 0 || status.stdout.trim()) return mtime;
+  const log = spawnSync('git', ['log', '-1', '--format=%cI', '--', name], { cwd: dir, encoding: 'utf8' });
+  const committed = log.status === 0 ? log.stdout.trim() : '';
+  return committed ? new Date(committed) : mtime;
+}
+
+function looksLikePath(text) {
+  if (!text || /\s/.test(text) || /^[a-z][a-z0-9+.-]*:\/\//i.test(text)) return false;
+  return text.includes('/') || /\.[A-Za-z0-9]+$/.test(text);
+}
+
+// A relative source can be written from the repo root, the page's own folder,
+// or any folder in between (a brief citing "briefs/x.md" from the wiki root).
+// The first place it exists wins; if none, the repo-root path is reported.
+function resolveSource(cwd, pagePath, filePart) {
+  if (path.isAbsolute(filePart)) return filePart;
+  const root = path.resolve(cwd);
+  const fromRoot = path.join(root, filePart);
+  if (fs.existsSync(fromRoot)) return fromRoot;
+  let dir = path.dirname(path.resolve(pagePath));
+  while (dir.startsWith(root + path.sep)) {
+    const candidate = path.join(dir, filePart);
+    if (fs.existsSync(candidate)) return candidate;
+    dir = path.dirname(dir);
+  }
+  return fromRoot;
+}
+
 /**
  * Parse frontmatter from a markdown file and check if any source is newer than last_compiled.
  * Returns { page, staleSource, compiledDate, sourceDate } or null if not stale.
@@ -675,15 +711,19 @@ function checkPageStaleness(cwd, filePath) {
       .replace(/\s*\([^)]*\)\s*$/, '')   // drop trailing "(annotation)"
       .replace(/:\d+(-\d+)?$/, '')        // drop trailing ":N" or ":N-M"
       .trim();
-    const sourcePath = path.isAbsolute(filePart) ? filePart : path.join(cwd, filePart);
+    // A plain-language source ("Voyage AI documentation") or a web link names
+    // no file, so it can never be missing on disk. Only paths are checked.
+    if (!looksLikePath(filePart)) continue;
+    const sourcePath = resolveSource(cwd, filePath, filePart);
     try {
       const stat = fs.statSync(sourcePath);
-      if (stat.mtime > compiledDate) {
+      const changed = stat.mtime > compiledDate ? contentChangedAt(sourcePath, stat.mtime) : null;
+      if (changed && changed > compiledDate) {
         return {
           page: filePath,
           staleSource: source,
           compiledDate: compiledMatch[1],
-          sourceDate: stat.mtime.toISOString().split('T')[0]
+          sourceDate: changed.toISOString().split('T')[0]
         };
       }
     } catch {
@@ -700,6 +740,22 @@ function checkPageStaleness(cwd, filePath) {
   return null;
 }
 
+// A day can already be archived when a late entry lands in its journal.
+// Renaming over the archive would erase it, so the late entry is added to the
+// end instead, unless the archive already holds it word for word.
+function moveIntoArchive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.renameSync(src, dest);
+    return;
+  }
+  const late = fs.readFileSync(src, 'utf8');
+  const kept = fs.readFileSync(dest, 'utf8');
+  if (late.trim() && !kept.includes(late.trim())) {
+    fs.writeFileSync(dest, `${kept.replace(/\n*$/, '\n')}\n${late}`);
+  }
+  fs.rmSync(src);
+}
+
 /**
  * Archive journals older than 30 days
  */
@@ -734,7 +790,7 @@ function archiveOldJournals(atrisDir, dryRun = false) {
           }
           const src = path.join(yearDir, file);
           const dest = path.join(archiveYearDir, file);
-          fs.renameSync(src, dest);
+          moveIntoArchive(src, dest);
         }
         archived++;
       }