atris 3.71.2 → 3.71.3

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

@@ -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');
@@ -251,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) {
@@ -301,7 +307,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)}`;
@@ -524,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;
@@ -544,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]);
@@ -661,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
@@ -676,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();
+    }
   }
 }
 
@@ -731,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', '');
@@ -755,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;

package/commands/pulse.js

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

package/commands/worktree.js

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