atris 3.70.0 → 3.71.1

package/lib/campaign-loop.js

@@ -0,0 +1,246 @@
+// The campaign loop: a campaign runs itself until its judge passes, its money
+// runs out, or it needs a person. Each step asks decide what to do, then does
+// it: run the judge, start claimed missions (several at once), or ask the
+// owner's engine to propose the next missions. Campaigns decide, missions do.
+
+'use strict';
+
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const { decide } = require('./campaign-core');
+const { getCampaign, openCampaignStore } = require('./campaign-store');
+const { defaultReserve, reconcileCampaign } = require('./campaign-missions');
+const { judgeRanData, latestJudgeOutput } = require('./campaign-reading');
+
+const TERMINAL = new Set(['stopped', 'complete']);
+
+const CLI = path.join(__dirname, '..', 'bin', 'atris.js');
+const PROPOSE_TIMEOUT_MS = 5 * 60 * 1000;
+
+function claimKey(objective) {
+  return String(objective).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().slice(0, 160);
+}
+
+function proposalId(objective) {
+  const slug = String(objective).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40).replace(/-+$/, '');
+  return `m-${slug || 'mission'}-${crypto.randomBytes(3).toString('hex')}`;
+}
+
+// What the owner's engine reads before proposing: the goal, how it is judged,
+// what has been tried, and how it went.
+function proposalPrompt(view, count, judgeOutput = null, lessons = '') {
+  const tried = view.missions.slice(-12).map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none yet';
+  const seats = view.seats.map((s) => s.member).filter(Boolean);
+  const members = [...new Set([view.owner, ...seats])];
+  return [
+    `You plan the next missions for an Atris campaign. Answer with JSON only.`,
+    ``,
+    `Campaign: ${view.title}`,
+    `Judge (the campaign is done when this command exits 0): ${view.judge}`,
+    `Last judge reading: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${typeof view.last_judge.reading === 'number' ? ` (${view.last_judge.reading} of 1)` : ''}: ${view.answer.text || ''}` : 'never run'}`,
+    judgeOutput ? `Last judge output:\n\`\`\`\n${judgeOutput.replace(/```/g, "'''")}\n\`\`\`` : '',
+    view.bet ? `Current bet: ${view.bet.text}${view.bet.wrong_if ? ` (wrong if ${view.bet.wrong_if})` : ''}` : '',
+    `Money left: $${view.budget.available.toFixed(2)} of $${view.budget.total.toFixed(2)}`,
+    `Members who can take a mission: ${members.join(', ')}`,
+    `Missions so far:`,
+    tried,
+    lessons ? `Lessons from earlier rounds (follow them):\n${lessons}` : '',
+    ``,
+    `Propose at most ${count} missions that move the judge toward passing. Each is one member, one run, one checkable result.`,
+    `Do not repeat a mission that was already kept. Prefer small, independent missions that can run at the same time.`,
+    `Reply with a JSON array and nothing else:`,
+    `[{"objective": "<one sentence, imperative>", "member": "<one of the members above>", "verify": "<shell command that exits 0 when this mission's result is real>", "estimate_usd": <dollars, small>}]`,
+  ].filter((line) => line !== '').join('\n');
+}
+
+function parseProposals(text, view, count) {
+  const match = String(text || '').match(/\[[\s\S]*\]/);
+  if (!match) return [];
+  let rows;
+  try {
+    rows = JSON.parse(match[0]);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(rows)) return [];
+  const members = new Set([view.owner, ...view.seats.map((s) => s.member)]);
+  return rows.slice(0, count)
+    .filter((row) => row && typeof row.objective === 'string' && row.objective.trim())
+    .map((row) => ({
+      objective: row.objective.trim().slice(0, 300),
+      member: members.has(row.member) ? row.member : view.owner,
+      verify: typeof row.verify === 'string' && row.verify.trim() ? row.verify.trim() : view.judge,
+      estimate_usd: typeof row.estimate_usd === 'number' && row.estimate_usd > 0 ? Math.min(row.estimate_usd, view.budget.available) : null,
+    }));
+}
+
+// Ask the owner's engine for proposals through the read-only ask runner.
+async function askOwner(root, view, prompt) {
+  const { resolveEngineForMember } = require('./member-engine');
+  const { runEngineAskJobs } = require('./engine-ask');
+  const pick = resolveEngineForMember(view.owner, root) || {};
+  const engine = (pick.engine && pick.engine.id) || 'claude';
+  const [answer] = await runEngineAskJobs([{ engine, model: pick.model || '', prompt, label: `campaign ${view.id} plan` }], { root, timeoutMs: PROPOSE_TIMEOUT_MS });
+  return { text: (answer && answer.stdout) || '', engine, ok: Boolean(answer && answer.ok) };
+}
+
+// Run one atris command and resolve with its exit code and output.
+function runCli(args, { cwd, env = process.env, onLine = null } = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [CLI, ...args], { cwd, env: { ...env, ATRIS_SKIP_UPDATE_CHECK: '1' }, stdio: ['ignore', 'pipe', 'pipe'] });
+    let out = '';
+    let err = '';
+    child.stdout.on('data', (chunk) => {
+      out += chunk;
+      if (onLine) String(chunk).split('\n').filter(Boolean).forEach(onLine);
+    });
+    child.stderr.on('data', (chunk) => { err += chunk; });
+    child.on('close', (code) => resolve({ code, out, err }));
+  });
+}
+
+function makeLoop(root, options = {}, deps = {}) {
+  const store = deps.store || openCampaignStore(root);
+  const log = deps.log || ((line) => console.log(line));
+  const parallel = Math.max(1, Number(options.parallel) || 3);
+  const maxTicks = Math.max(1, Number(options.maxTicks) || 3);
+  // Every mission gets an explicit time limit. Without one, a number in the
+  // objective ("437 tests, 475s") was read as the mission's time budget.
+  const missionMinutes = Math.max(1, Number(options.missionMinutes) || 40);
+  const runner = options.runner || 'auto';
+  const actor = options.actor || 'mission-lead';
+  const ask = deps.ask || askOwner;
+  const cli = deps.cli || ((args) => runCli(args, { cwd: root }));
+  const judge = deps.judge;
+
+  const view = (id) => getCampaign(store, id);
+  const append = (id, type, data, as = actor) => store.append({ campaign_id: id, type, actor: as, data });
+
+  async function propose(id, count = parallel) {
+    const current = view(id);
+    const prompt = proposalPrompt(current, count, latestJudgeOutput(store.read(id)), deps.lessons ? deps.lessons(id) : '');
+    const answer = await ask(root, current, prompt);
+    const proposals = parseProposals(answer.text, current, count);
+    // Planning costs money too. It rides on the first mission it produced as a
+    // step, so it is counted when that mission ends without making the judge
+    // due. A plan that produced nothing becomes its own ended mission.
+    const plan = { kind: 'plan', engine: answer.engine };
+    if (typeof answer.cost_usd === 'number') plan.cost_usd = answer.cost_usd;
+    proposals.forEach((proposal, index) => {
+      const missionId = proposalId(proposal.objective);
+      append(id, 'mission_proposed', { mission_id: missionId, member: proposal.member, objective: proposal.objective, verify: proposal.verify, estimate_usd: proposal.estimate_usd || undefined }, proposal.member);
+      append(id, 'mission_claimed', { mission_id: missionId, claim_key: claimKey(proposal.objective) }, proposal.member);
+      if (index === 0) append(id, 'step', { mission_id: missionId, ...plan }, current.owner);
+    });
+    if (!proposals.length) {
+      const planId = `plan-${crypto.randomBytes(3).toString('hex')}`;
+      append(id, 'mission_started', { mission_id: planId, member: current.owner, kind: 'plan' }, current.owner);
+      append(id, 'mission_ended', { mission_id: planId, outcome: 'failed', cost_usd: plan.cost_usd || 0, uncosted_runs: plan.cost_usd === undefined ? 1 : 0, engine: answer.engine }, current.owner);
+    }
+    return proposals;
+  }
+
+  // The proposal data behind each claimed mission (the fold keeps only ids).
+  function claimedWork(id) {
+    const current = view(id);
+    const proposals = new Map();
+    for (const event of store.read(id)) {
+      if (event.type === 'mission_proposed' && event.data.objective) proposals.set(event.data.mission_id, event.data);
+    }
+    return current.missions
+      .filter((m) => m.status === 'claimed' && proposals.has(m.id))
+      .map((m) => ({ ...proposals.get(m.id), mission_id: m.id, member: m.member || proposals.get(m.id).member || current.owner }));
+  }
+
+  async function startAndRun(id, work) {
+    const current = view(id);
+    const reserve = work.estimate_usd || defaultReserve(current);
+    const started = await cli([
+      'mission', 'start', work.objective, '--mission-id', work.mission_id, '--owner', work.member,
+      '--runner', runner, '--verify', work.verify || current.judge, '--campaign', id, '--reserve', String(reserve),
+      '--max-wall', String(missionMinutes * 60), '--json',
+    ]);
+    if (started.code !== 0) {
+      const why = (started.out + started.err).trim().split('\n').pop();
+      log(`  ${work.mission_id} did not start: ${why}`);
+      append(id, 'mission_vetoed', { mission_id: work.mission_id, reason: why.slice(0, 200) }, current.owner);
+      return { mission_id: work.mission_id, started: false };
+    }
+    log(`  ${work.mission_id} started for ${work.member}: ${work.objective}`);
+    const ran = await cli(['mission', 'run', work.mission_id, '--max-ticks', String(maxTicks), '--complete-on-pass']);
+    const after = view(id).missions.find((m) => m.id === work.mission_id);
+    if (after && after.status !== 'ended') {
+      // The run stopped without finishing (tick cap, error): close it so its
+      // reserve comes back and its cost is counted.
+      await cli(['mission', 'stop', work.mission_id, '--reason', `campaign loop: run ended without finishing (exit ${ran.code})`]);
+    }
+    const final = view(id).missions.find((m) => m.id === work.mission_id) || {};
+    log(`  ${work.mission_id} ${final.outcome || 'ended'} · $${(final.cost_usd || 0).toFixed(2)}`);
+    return { mission_id: work.mission_id, started: true, outcome: final.outcome || null };
+  }
+
+  // A campaign linked to the cloud trades events before and after every step,
+  // so a person's answer from a phone reaches this loop. A failed sync never
+  // stops the loop; deps.sync warns, keeps running offline, and resolves with
+  // how many events it pulled.
+  const sync = deps.sync || (async () => 0);
+
+  // One step, with a sync on each side.
+  async function step(id) {
+    await sync(id);
+    const result = await stepOnce(id);
+    await sync(id);
+    return result;
+  }
+
+  // One step. Returns { stop, reason } or { stop: false, did }.
+  async function stepOnce(id) {
+    // Missions that ended without telling the campaign give their reserve back first.
+    if (!deps.skipReconcile) {
+      try { reconcileCampaign(root, id, TERMINAL, { store }); } catch {}
+    }
+    const current = view(id);
+    if (!current) return { stop: true, reason: `no campaign ${id}` };
+    if (current.error) return { stop: true, reason: `campaign cannot be read: ${current.error}` };
+    const move = decide(current);
+    if (move.action === 'none') return { stop: true, reason: move.reason };
+    if (move.action === 'wait' && move.reason === 'open asks') return { stop: true, reason: `needs you: ${move.asks.length} open ask${move.asks.length === 1 ? '' : 's'}` };
+    if (move.action === 'run_judge') {
+      const reading = await judge(current.judge);
+      append(id, 'judge_ran', judgeRanData(reading), 'judge');
+      log(`judge ${reading.passed ? 'passed' : 'failed'}: ${reading.summary || `exit ${reading.exit}`}`);
+      return { stop: false, did: 'judge' };
+    }
+    if (move.action === 'start_mission' || (move.action === 'wait' && move.reason === 'budget')) {
+      const work = claimedWork(id).slice(0, parallel);
+      if (!work.length) return { stop: true, reason: 'claimed missions have no objective to run; start them by hand or veto them' };
+      log(`starting ${work.length} mission${work.length === 1 ? '' : 's'} at once`);
+      const results = await Promise.all(work.map((w) => startAndRun(id, w)));
+      if (!results.some((r) => r.started)) return { stop: true, reason: 'no claimed mission could start' };
+      return { stop: false, did: 'missions' };
+    }
+    if (move.action === 'wait') return { stop: true, reason: `waiting: ${move.reason} (started elsewhere)` };
+    log(`asking ${current.owner} to propose up to ${parallel} missions`);
+    const proposals = await propose(id, parallel);
+    if (!proposals.length) return { stop: true, reason: `${current.owner} proposed nothing usable` };
+    for (const p of proposals) log(`  proposed for ${p.member}: ${p.objective}`);
+    return { stop: false, did: 'propose' };
+  }
+
+  async function run(id, maxSteps = 20) {
+    await sync(id);
+    for (let i = 0; i < maxSteps; i++) {
+      const result = await stepOnce(id);
+      // An answer pulled just now can unblock a step that stopped for a person.
+      const pulled = await sync(id);
+      if (result.stop && pulled > 0) continue;
+      if (result.stop) return { steps: i, reason: result.reason, campaign: view(id) };
+    }
+    return { steps: maxSteps, reason: `stopped after ${maxSteps} steps`, campaign: view(id) };
+  }
+
+  return { step, run, propose };
+}
+
+module.exports = { askOwner, makeLoop, parseProposals, proposalPrompt };

package/lib/campaign-missions.js

@@ -0,0 +1,237 @@
+// Missions that belong to a campaign (build.md Phase 3). commands/mission.js
+// calls these at start and on every save; a mission with no campaign_id never
+// reaches the store, so plain missions run exactly as before.
+
+'use strict';
+
+const { decide } = require('./campaign-core');
+const { getCampaign, openCampaignStore } = require('./campaign-store');
+
+const DEFAULT_RESERVE_USD = 5;
+const CLOSED_STATES = new Set(['done', 'out_of_budget', 'paused']);
+
+function storeFor(root, deps = {}) {
+  return deps.store || openCampaignStore(root);
+}
+
+function warn(message) {
+  process.stderr.write(`campaign: ${message}\n`);
+}
+
+// How much a new mission holds back: what missions in this campaign have cost
+// on average, or $5 before any has ended. --reserve overrides.
+function defaultReserve(view) {
+  const ended = view.missions.filter((m) => m.status === 'ended' && typeof m.cost_usd === 'number');
+  if (!ended.length) return DEFAULT_RESERVE_USD;
+  const average = ended.reduce((sum, m) => sum + m.cost_usd, 0) / ended.length;
+  return Math.max(0.01, Math.ceil(average * 100) / 100);
+}
+
+// Checked before a mission creates anything, so a refusal leaves nothing behind.
+function checkCampaignStart(root, campaignId, options = {}, deps = {}) {
+  const store = storeFor(root, deps);
+  const view = getCampaign(store, campaignId);
+  if (!view) return { ok: false, error: `no campaign ${campaignId}. See them with: atris campaign` };
+  if (view.error) return { ok: false, error: `campaign ${campaignId} cannot be read: ${view.error}` };
+  if (CLOSED_STATES.has(view.state)) {
+    return { ok: false, error: `campaign ${campaignId} is ${view.state.replace(/_/g, ' ')}, so it takes no new missions` };
+  }
+  if (options.missionId) {
+    const owner = store.campaignForMission(options.missionId);
+    if (owner && owner !== campaignId) return { ok: false, error: `mission ${options.missionId} already belongs to campaign ${owner}` };
+  }
+  const reserve = options.reserveUsd !== undefined && options.reserveUsd !== null && options.reserveUsd !== ''
+    ? Number(options.reserveUsd)
+    : defaultReserve(view);
+  if (!(reserve >= 0) || !Number.isFinite(reserve)) return { ok: false, error: '--reserve takes dollars, for example --reserve 5' };
+  if (reserve > view.budget.available) {
+    return {
+      ok: false,
+      error: `campaign ${campaignId} has $${view.budget.available.toFixed(2)} left and this mission would hold $${reserve.toFixed(2)}. Add money with: atris campaign budget ${campaignId} --add <dollars>`,
+    };
+  }
+  return { ok: true, campaign: view, reserve };
+}
+
+// Hold the reserve in one transaction with the check, so missions starting at
+// the same moment can never hold more than the campaign has left.
+function reserveCampaignMission(root, campaignId, missionId, amount, actor, deps = {}) {
+  if (!(amount > 0)) return null;
+  const store = storeFor(root, deps);
+  return store.append({ campaign_id: campaignId, type: 'budget_reserved', actor, data: { mission_id: missionId, amount_usd: amount } }, {
+    check: (view) => {
+      if (view.error) throw Object.assign(new Error(`campaign ${campaignId} cannot be read: ${view.error}`), { code: 'campaign_unreadable' });
+      if (CLOSED_STATES.has(view.state)) throw Object.assign(new Error(`campaign ${campaignId} is ${view.state.replace(/_/g, ' ')}, so it takes no new missions`), { code: 'campaign_closed' });
+      if (amount > view.budget.available) {
+        throw Object.assign(new Error(`campaign ${campaignId} has $${view.budget.available.toFixed(2)} left and this mission would hold $${amount.toFixed(2)}. Add money with: atris campaign budget ${campaignId} --add <dollars>`), { code: 'campaign_tank' });
+      }
+    },
+  });
+}
+
+// Before each tick: a mission stops working when its campaign is done,
+// paused, or out of money. Returns the pause reason, or null to keep going.
+function campaignGate(root, mission, deps = {}) {
+  if (!mission || !mission.campaign_id) return null;
+  try {
+    const view = getCampaign(storeFor(root, deps), mission.campaign_id);
+    if (!view || view.error) return null;
+    if (CLOSED_STATES.has(view.state)) return `campaign-${view.state.replace(/_/g, '-')}`;
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function readMissionLedger(root) {
+  const file = require('path').join(root, '.atris', 'state', 'missions.jsonl');
+  const latest = new Map();
+  let text = '';
+  try { text = require('fs').readFileSync(file, 'utf8'); } catch { return latest; }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row && row.id) latest.set(row.id, row);
+    } catch {}
+  }
+  return latest;
+}
+
+// Missions the campaign still counts as running whose mission record says
+// they are over, or that never got a record (a start that crashed after its
+// reserve): end them in the campaign so their reserve comes back.
+function reconcileCampaign(root, campaignId, terminalStatuses, deps = {}) {
+  const store = storeFor(root, deps);
+  const view = getCampaign(store, campaignId);
+  if (!view || view.error) return [];
+  const ledger = (deps.readLedger || readMissionLedger)(root);
+  const ended = [];
+  const reservedOnly = new Set();
+  for (const event of store.read(campaignId)) {
+    if (event.type === 'budget_reserved' && !view.missions.some((m) => m.id === event.data.mission_id)) reservedOnly.add(event.data.mission_id);
+    if (event.type === 'budget_released') reservedOnly.delete(event.data.mission_id);
+  }
+  for (const missionId of reservedOnly) {
+    if (ledger.has(missionId)) continue;
+    store.append({ campaign_id: campaignId, type: 'budget_released', actor: 'system', data: { mission_id: missionId, reason: 'mission was never created' } });
+    ended.push(missionId);
+  }
+  for (const m of view.missions) {
+    if (m.status !== 'running' || m.id.startsWith('plan-')) continue;
+    const record = ledger.get(m.id);
+    if (record && !terminalStatuses.has(record.status)) continue;
+    if (!record && !deps.endMissing) continue;
+    const result = recordCampaignMissionEnded(root, { status: 'running' }, { ...(record || { id: m.id, owner: m.member, status: 'stopped' }), campaign_id: campaignId }, terminalStatuses, deps);
+    if (result) ended.push(m.id);
+  }
+  return ended;
+}
+
+function memberOf(mission) {
+  return mission.owner || mission.executed_by || 'mission-lead';
+}
+
+// After the mission is saved: it starts in the campaign and holds its reserve.
+function recordCampaignMissionStarted(root, mission, reserve, deps = {}) {
+  if (!mission || !mission.campaign_id) return null;
+  try {
+    const store = storeFor(root, deps);
+    const actor = memberOf(mission);
+    store.append({
+      campaign_id: mission.campaign_id, type: 'mission_started', actor,
+      data: {
+        mission_id: mission.id, member: actor, objective: String(mission.objective || '').slice(0, 200),
+        ...(mission.runner && mission.runner !== 'auto' ? { engine: mission.runner } : {}),
+        ...(mission.model ? { model: mission.model } : {}),
+      },
+    });
+    if (reserve > 0) {
+      store.append({ campaign_id: mission.campaign_id, type: 'budget_reserved', actor, data: { mission_id: mission.id, amount_usd: reserve } });
+    }
+    return getCampaign(store, mission.campaign_id);
+  } catch (error) {
+    warn(`mission ${mission.id} started, but campaign ${mission.campaign_id} did not record it: ${error.message}`);
+    return null;
+  }
+}
+
+// Each tick writes a step into the campaign with the dollars its engine
+// reported, so the campaign's own log holds the spend: no lookback window, and
+// every runner counts, including ones that run without a roster pick.
+function recordCampaignTick(root, mission, usage = {}, deps = {}) {
+  if (!mission || !mission.campaign_id) return;
+  const data = { mission_id: mission.id };
+  if (typeof usage.cost_usd === 'number' && Number.isFinite(usage.cost_usd)) data.cost_usd = usage.cost_usd;
+  if (typeof usage.tokens === 'number' && Number.isFinite(usage.tokens)) data.tokens = usage.tokens;
+  // Which engine did the work: traces and per-engine cost need it.
+  if (typeof usage.engine === 'string' && usage.engine) data.engine = usage.engine;
+  try {
+    storeFor(root, deps).append({ campaign_id: mission.campaign_id, type: 'step', actor: memberOf(mission), data });
+  } catch (error) {
+    warn(`a tick of mission ${mission.id} was not recorded in campaign ${mission.campaign_id}: ${error.message}`);
+  }
+}
+
+// Dollars the mission's ticks reported, from the campaign's own steps. Ticks
+// without a dollar figure (engines that print tokens only) are counted so the
+// campaign can say spend is partial.
+function missionCost(root, missionId, deps = {}) {
+  const store = storeFor(root, deps);
+  const campaignId = store.campaignForMission(missionId);
+  const rows = campaignId
+    ? store.read(campaignId).filter((e) => e.type === 'step' && e.data.mission_id === missionId).map((e) => e.data)
+    : [];
+  let cents = 0;
+  let uncosted = 0;
+  // A cost that is not a real, non-negative number never blocks the mission's
+  // end; that tick counts as one without a dollar figure.
+  for (const row of rows) {
+    if (typeof row.cost_usd === 'number' && Number.isFinite(row.cost_usd) && row.cost_usd >= 0) cents += Math.floor(row.cost_usd * 100 + 0.5);
+    else uncosted += 1;
+  }
+  return { cost_usd: cents / 100, runs: rows.length, uncosted_runs: uncosted };
+}
+
+function outcomeFor(mission) {
+  return mission.status === 'complete' ? 'kept' : 'failed';
+}
+
+// Called from saveMission with the record before and after. Only the step
+// into a final status ends the mission in its campaign.
+function recordCampaignMissionEnded(root, previous, next, terminalStatuses, deps = {}) {
+  if (!next || !next.campaign_id || !terminalStatuses.has(next.status)) return null;
+  if (previous && terminalStatuses.has(previous.status)) return null;
+  try {
+    const store = storeFor(root, deps);
+    const view = getCampaign(store, next.campaign_id);
+    const known = view && !view.error && view.missions.find((m) => m.id === next.id);
+    if (known && known.status === 'ended') return null;
+    const cost = missionCost(root, next.id, deps);
+    const actor = memberOf(next);
+    store.append({
+      campaign_id: next.campaign_id, type: 'mission_ended', actor,
+      data: {
+        mission_id: next.id, outcome: outcomeFor(next), cost_usd: cost.cost_usd,
+        runs: cost.runs, uncosted_runs: cost.uncosted_runs, receipt_path: next.receipt_path || null,
+      },
+    });
+    const after = getCampaign(store, next.campaign_id);
+    return after ? { campaign: after, next: decide(after), cost } : null;
+  } catch (error) {
+    warn(`mission ${next.id} ended, but campaign ${next.campaign_id} did not record it: ${error.message}`);
+    return null;
+  }
+}
+
+module.exports = {
+  campaignGate,
+  reconcileCampaign,
+  reserveCampaignMission,
+  checkCampaignStart,
+  defaultReserve,
+  missionCost,
+  recordCampaignMissionEnded,
+  recordCampaignMissionStarted,
+  recordCampaignTick,
+};