atris 3.71.1 → 3.71.3

package/atris/skills/campaigns/SKILL.md

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

package/atris.md

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

package/bin/atris.js

@@ -2018,7 +2018,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)))

package/commands/campaign.js

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

package/commands/improve.js

@@ -528,7 +528,7 @@ function collectImproveVitals(options = {}, deps = {}) {
   };
 
   // The guarantee gauge: agent landings vs human fixes over the last 14 days.
-  // Collection is bounded by --since so a huge repo only walks a fortnight.
+  // The lookback filters results while traversal can visit older ancestors.
   // No git history (not a repo, git missing) means the line is omitted silently.
   let guarantee = null;
   try {
@@ -1313,7 +1313,8 @@ function collectRevisionSignals(root, options = {}) {
 
   let raw = '';
   try {
-    raw = gitLines(root, ['log', `--since=${sinceIso}`, '--date=iso-strict', '--pretty=format:%H%x1f%P%x1f%aI%x1f%s%x1f%B%x1e']);
+    // Filter dates without pruning ancestors behind an older-dated descendant.
+    raw = gitLines(root, ['log', `--since-as-filter=${sinceIso}`, '--date=iso-strict', '--pretty=format:%H%x1f%P%x1f%aI%x1f%s%x1f%B%x1e']);
   } catch (e) {
     // a repo with no commits yet exits non-zero on `git log`; that is the
     // empty-history case, not an error. anything else (not a repo) rethrows.

package/commands/mission.js

@@ -64,6 +64,7 @@ const {
   renderMorningCardRow,
 } = require('../lib/receipt-block');
 const { findCachedMissionStepReceipt } = require('../lib/receipt-evidence');
+const { captureCodeBaseline, collectCodeProvenance } = require('../lib/mission-code-provenance');
 const {
   pruneRuns,
   runsPruneLines,
@@ -4402,6 +4403,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
   nextMission.next_action = `decide next mission, then run: ${nextPlan.command}`;
   nextMission.next_action_preview = nextPlan.preview;
 
+  const codeBaseline = captureCodeBaseline(root);
   ensureMemberMissionFile(nextMission.owner, root, nextMission.objective);
   const { mission: saved } = saveMission(assignMissionNumber(nextMission, root), root, 'mission_continuation_started', {
     parent_mission_id: parent.id,
@@ -4409,7 +4411,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
     proof: proof || null,
   });
   if (saved.campaign_id) campaignMissions().recordCampaignMissionStarted(root, saved, 0);
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, root);
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, root, codeBaseline);
   const seededAt = stampIso();
   const { mission: updatedParent } = saveMission({
     ...parent,
@@ -4656,6 +4658,7 @@ function startMission(args, options = {}) {
     if (nodeModulesSource) mission.node_modules_source = nodeModulesSource;
     process.chdir(created.path);
   }
+  const codeBaseline = captureCodeBaseline(process.cwd());
   if (mission.xp_task_enabled) {
     const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
     mission.xp_task = xpTask;
@@ -4696,7 +4699,7 @@ function startMission(args, options = {}) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd(), codeBaseline);
   const nextTickCommand = `atris mission tick ${saved.id}${saved.verifier ? ' --verify' : ''}`;
   const payload = {
     ok: true,
@@ -4738,6 +4741,7 @@ function startMission(args, options = {}) {
 
 async function startMissionFromRunObjective(objective, args) {
   const asJson = wantsJson(args);
+  const codeBaseline = captureCodeBaseline(process.cwd());
   const rawObjective = String(objective || '').trim();
   const landRun = hasFlag(args, '--land');
   const dryRun = hasFlag(args, '--dry-run');
@@ -4939,7 +4943,7 @@ async function startMissionFromRunObjective(objective, args) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd(), codeBaseline);
   const completedContinuationGoal = completeActiveContinuationForStartedMission(saved, process.cwd());
   const nativeGoalOptions = codexNativeGoalOptionsFromArgs(args);
   const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
@@ -6629,6 +6633,7 @@ function writeReceipt(mission, result, root = process.cwd()) {
     tree_hash: treeHashFor(root),
     clean: codeState.clean,
     git_tree: codeState.clean ? codeState.tree : null,
+    code_provenance: collectCodeProvenance(root, loadMissionWorktreeBaseline(mission.id, root)?.code),
     mission_id: mission.id,
     objective: mission.objective,
     owner: mission.owner,
@@ -6864,7 +6869,7 @@ function missionBaselinePath(missionId, root = process.cwd()) {
 // Stored outside missions.jsonl because that log re-appends the full mission
 // record on every save. Captured after start bookkeeping so the mission's own
 // state writes land inside the baseline, not in new_since_baseline.
-function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
+function captureMissionWorktreeBaseline(mission, root = process.cwd(), code = captureCodeBaseline(root)) {
   const snapshot = gitWorktreeSnapshot(root);
   if (!snapshot.available) return null;
   const baselineFile = missionBaselinePath(mission.id, root);
@@ -6880,6 +6885,7 @@ function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
     dirty_count: snapshot.dirty_count,
     dirty_hash: snapshot.dirty_hash,
     paths: Array.from(paths).sort(),
+    code,
   };
   writeJson(baselineFile, baseline);
   return baseline;
@@ -6989,18 +6995,34 @@ const CLAUDE_SESSION_CONTEXT_ROTATE_TICKS = Math.max(
 // before the tick fires. Same tag-plus-text routing the task lane uses
 // (CLI-1189). An operator override is explicit: protected_lane_ack in the
 // mission metadata, set by a human, or ATRIS_ALLOW_PROTECTED_MISSION=1.
-function missionProtectedLaneHold(mission) {
+function missionProtectedLaneHold(mission, root = process.cwd()) {
   if (process.env.ATRIS_ALLOW_PROTECTED_MISSION === '1') return null;
   if (mission?.metadata?.protected_lane_ack) return null;
   const { DENIED_TAGS } = require('../lib/fleet');
   const { declaredProtectedLane, sniffedProtectedLane } = require('../lib/auto-accept-certified');
   const lane = String(mission?.lane || '').toLowerCase();
-  if (DENIED_TAGS.includes(lane)) return { pause_reason: `protected-lane-${lane}` };
   const probe = { title: mission?.objective, objective: mission?.stop_condition, metadata: mission?.metadata || {} };
-  if (declaredProtectedLane(probe)) return { pause_reason: 'protected-lane-declared' };
-  const sniffed = sniffedProtectedLane(probe);
-  if (sniffed) return { pause_reason: `protected-lane-${sniffed.lane}` };
-  return null;
+  let hold = null;
+  if (DENIED_TAGS.includes(lane)) hold = { pause_reason: `protected-lane-${lane}`, lane };
+  else if (declaredProtectedLane(probe)) hold = { pause_reason: 'protected-lane-declared', lane: 'declared' };
+  else {
+    const sniffed = sniffedProtectedLane(probe);
+    if (sniffed) hold = { pause_reason: `protected-lane-${sniffed.lane}`, lane: sniffed.lane };
+  }
+  // Inside a campaign, a person may have allowed this lane by answering the
+  // campaign's ask. Only a person's answer closes an ask, so it counts as the ack.
+  if (hold && mission?.campaign_id && campaignApprovedLane(root, mission.campaign_id, hold.lane)) return null;
+  return hold ? { pause_reason: hold.pause_reason } : null;
+}
+
+function campaignApprovedLane(root, campaignId, lane) {
+  try {
+    const { openCampaignStore } = require('../lib/campaign-store');
+    const { approvedLanes } = require('../lib/campaign-lanes');
+    return approvedLanes(openCampaignStore(root).read(campaignId)).has(lane);
+  } catch {
+    return false;
+  }
 }
 
 function runnerUsesCallerSession(runner) {
@@ -10342,7 +10364,7 @@ async function executeMissionRunTicksPhase(context) {
       if (['complete', 'stopped', 'paused'].includes(mission.status)) { pauseReason = mission.status; break; }
       if (effectiveMissionVerifier(mission) !== storedVerifier) { pauseReason = 'verifier-mutated'; break; }
       if ((mission.lane || 'workspace') !== frozen.lane) { pauseReason = 'lane-mutated'; break; }
-      const protectedHold = missionProtectedLaneHold(mission);
+      const protectedHold = missionProtectedLaneHold(mission, cwd);
       if (protectedHold) { pauseReason = protectedHold.pause_reason; break; }
 
       const tickIdx = Number(mission.last_tick_index || 0) + 1;