atris 3.70.0 → 3.71.1

package/commands/youtube.js

@@ -1239,17 +1239,32 @@ function buildDigestPrompt(briefs = []) {
 
 function defaultDigestRunner(prompt, deps = {}) {
   const spawn = deps.spawnSync || spawnSync;
-  return spawn('claude', ['-p', prompt, '--model', 'claude-haiku-5-5'], {
+  // Machine memory and load at both ends of the launch, so one killed with
+  // SIGKILL says whether the machine was short on memory.
+  const endResource = require('../lib/engine-resource').startEngineRun(deps.cwd || process.cwd(), { engine: 'claude', task: 'youtube digest' });
+  const result = spawn('claude', ['-p', prompt, '--model', 'claude-haiku-5-5'], {
     encoding: 'utf8',
     timeout: DIGEST_ENGINE_TIMEOUT_MS,
     maxBuffer: 10 * 1024 * 1024,
   });
+  // spawnSync does not throw, so a failure is passed in the thrown shape.
+  const failed = !result || result.error || result.signal || result.status !== 0;
+  const end = endResource(failed ? {
+    code: result && result.error && result.error.code,
+    signal: result && result.signal,
+    stderr: result && result.stderr,
+    message: result && result.error ? result.error.message : `claude exited ${result && result.status}`,
+  } : null);
+  return end && end.cause && result && !(result.error && result.error.code === 'ETIMEDOUT') ? { ...result, cause: end.cause } : result;
 }
 
 function invokeDigestEngine(prompt, deps = {}) {
   const runner = deps.runner || ((nextPrompt) => defaultDigestRunner(nextPrompt, deps));
   const result = runner(prompt, deps);
   if (typeof result === 'string') return result.trim();
+  if (result && result.signal && !result.error) {
+    throw new Error(`digest engine stopped by ${result.signal}${result.cause ? `; ${result.cause}` : ''}`);
+  }
   if (!result || result.error || (result.status != null && result.status !== 0)) {
     const detail = String(result?.stderr || result?.error?.message || 'digest engine failed').trim();
     throw new Error(detail || 'digest engine failed');
@@ -1401,7 +1416,7 @@ function runYoutubeDigest(args = [], deps = {}) {
   const prompt = buildDigestPrompt(briefs);
   let text;
   try {
-    text = invokeDigestEngine(prompt, deps);
+    text = invokeDigestEngine(prompt, { ...deps, cwd });
   } catch (err) {
     output(err.message || 'digest engine failed');
     return 1;

package/lib/accept-verify-gate.js

@@ -123,4 +123,5 @@ function evaluateAcceptVerify(task, workspaceRoot, { cache = null } = {}) {
 module.exports = {
   storedVerifyCommand,
   evaluateAcceptVerify,
+  nonFalsifyingIssue,
 };

package/lib/account-bound.js

@@ -20,6 +20,14 @@ function isProvisionedAgentWorkspace(cwd = process.cwd()) {
   return fs.existsSync(path.join(root, '.atris', 'agent-token.json'));
 }
 
+// A Desktop project folder carries an atris/ directory but no business.json.
+// It is a real workspace, not a scratch folder, so account reads may run
+// there. Writes (send, dm, archive, connect) still need the business binding.
+function isProjectWorkspace(cwd = process.cwd()) {
+  const root = path.resolve(cwd);
+  return fs.existsSync(path.join(root, 'atris'));
+}
+
 function isHelpArg(arg) {
   return arg === '--help' || arg === '-h' || arg === 'help';
 }
@@ -33,6 +41,8 @@ function looksLikeBusinessSlug(token) {
 /**
  * Account-scoped verbs dump live CRM/cloud state. Outside a bound business
  * workspace they must opt in with --account. Help always passes.
+ * Pass { read: true } for read-only verbs: a project folder with atris/ (no
+ * business.json) then counts as bound. Writes never get that relaxation.
  * Returns { ok, args } where args has --account stripped when continuing.
  */
 function requireAccountBound(args = [], options = {}) {
@@ -44,6 +54,9 @@ function requireAccountBound(args = [], options = {}) {
   if (isBoundBusinessWorkspace(cwd) || isProvisionedAgentWorkspace(cwd)) {
     return { ok: true, args: list.filter((arg) => arg !== '--account'), bound: true };
   }
+  if (options.read === true && isProjectWorkspace(cwd)) {
+    return { ok: true, args: list.filter((arg) => arg !== '--account'), bound: true, project: true };
+  }
   if (list.includes('--account')) {
     return { ok: true, args: list.filter((arg) => arg !== '--account'), account: true };
   }

package/lib/auto-accept-certified.js

@@ -1398,6 +1398,7 @@ module.exports = {
   DENIED_TAGS,
   deniedTagOf,
   candidatePolicyGate,
+  declaredCandidatePathValues,
   declaredProtectedLane,
   sniffedProtectedLane,
   protectedLaneOf,

package/lib/autoland.js

@@ -267,6 +267,8 @@ function acceptedInLastDay(tasks, now = Date.now()) {
       result: String(t.result || t.metadata?.result || '').slice(0, 220),
       happened: String(t.review?.landing?.happened || t.metadata?.landing_happened || '').slice(0, 300),
       member: String(t.claimed_by || t.metadata?.executed_by || t.assigned_to || '').trim(),
+      // Accepted is a review verdict; only a passed landing proof is landed.
+      landed: t.metadata?.landing?.status === 'landed',
     };
     if (t.metadata?.auto_accepted_at) auto.push(entry);
     else human.push(entry);
@@ -481,6 +483,9 @@ function unexplainedSummaryRows(items, label) {
   if (label === 'landed') {
     return [`${plur(count, 'landed result')} stayed hidden because ${count === 1 ? 'its outcome was' : 'their outcomes were'} unclear`];
   }
+  if (label === 'accepted') {
+    return [`${plur(count, 'accepted result')} stayed hidden because ${count === 1 ? 'its outcome was' : 'their outcomes were'} unclear`];
+  }
   if (label === 'in review') {
     return [`${plur(count, 'review')} stayed hidden because ${count === 1 ? 'its next action was' : 'their next actions were'} unclear`];
   }
@@ -547,6 +552,10 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
   lines.push(`atris ${project}: last 24 hours`);
   const autoCount = accepted.auto.length;
   const humanCount = accepted.human.length;
+  const landedCount = accepted.auto.filter((item) => item.landed === true).length;
+  // "N landed" only when every one of them proved it; otherwise say both.
+  const finished = landedCount === autoCount ? `${autoCount} landed` : `${autoCount} accepted, ${landedCount} landed`;
+  const finishedWord = landedCount === autoCount ? 'landed' : 'accepted';
   const wishWaits = (Array.isArray(waitingWishes) ? waitingWishes : [])
     .filter((wish) => wish && String(wish.text || '').trim());
   if (autoCount > 0) {
@@ -564,8 +573,8 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
       // The header states the actual bar: under accept-all the claim
       // "verified twice" would be a lie the operator builds trust on.
       lines.push(acceptAll
-        ? `${autoCount} landed; ${plur(ready.length, 'clear result')}, protected lanes held back for you:`
-        : `${autoCount} landed; ${plur(ready.length, 'clear result')}, each verified twice with proof on file:`);
+        ? `${finished}; ${plur(ready.length, 'clear result')}, protected lanes held back for you:`
+        : `${finished}; ${plur(ready.length, 'clear result')}, each verified twice with proof on file:`);
       for (const { item, line } of visibleWork) {
         lines.push('');
         lines.push(`- ${line || item.ref}${memberTrustLabel(item.member, root)}`);
@@ -577,9 +586,9 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
           : `${plur(held, 'more result')} when you want them: atris autoland digest`);
       }
     } else {
-      lines.push(`${autoCount} landed with proof on file; no clear result was ready to show:`);
+      lines.push(`${finished} with proof on file; no clear result was ready to show:`);
     }
-    for (const row of unexplainedSummaryRows(unexplainedWork, 'landed')) lines.push(row);
+    for (const row of unexplainedSummaryRows(unexplainedWork, finishedWord)) lines.push(row);
   }
   if (autoCount + humanCount === 0) lines.push('nothing finished in the last day');
   if (waiting.length > 0) {

package/lib/campaign-cadence.js

@@ -0,0 +1,131 @@
+// Work and review in rounds (Astra's rule: let agents work 50 minutes, then
+// take 10). In the work window the campaign loop runs: it plans, runs missions
+// at once, and judges. In the break the judge runs if due, reserves are
+// reconciled, and the owner writes a short review of the round into the
+// campaign's lessons file, which the next round's planning reads. Each round
+// leaves the campaign a little smarter than the last.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getCampaign, openCampaignStore } = require('./campaign-store');
+
+const LESSON_LINES_FOR_PLANNING = 30;
+
+function parseDuration(text, fallbackMs) {
+  if (text === undefined || text === null || text === '') return fallbackMs;
+  const match = /^(\d+(?:\.\d+)?)\s*(s|m|h)?$/i.exec(String(text).trim());
+  if (!match) throw new Error(`durations look like 50m, 10m, 90s, or 1h (got ${text})`);
+  const unit = (match[2] || 'm').toLowerCase();
+  return Math.round(Number(match[1]) * { s: 1000, m: 60000, h: 3600000 }[unit]);
+}
+
+function lessonsPath(root, campaignId) {
+  return path.join(root, 'atris', 'campaigns', campaignId, 'lessons.md');
+}
+
+// The newest lessons, for the planner.
+function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+  try {
+    const text = fs.readFileSync(lessonsPath(root, campaignId), 'utf8');
+    return text.split('\n').filter((line) => line.trim().startsWith('- ')).slice(-lines).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+function roundSummary(before, after) {
+  const fresh = after.missions.filter((m) => !before.missions.some((b) => b.id === m.id && b.status === m.status));
+  const kept = fresh.filter((m) => m.status === 'ended' && m.outcome === 'kept').length;
+  const failed = fresh.filter((m) => m.status === 'ended' && m.outcome !== 'kept').length;
+  const vetoed = fresh.filter((m) => m.status === 'vetoed').length;
+  const spent = Math.round((after.budget.spent - before.budget.spent) * 100) / 100;
+  return { kept, failed, vetoed, spent, fresh };
+}
+
+function reviewPrompt(view, summary, lessons) {
+  const missions = summary.fresh.map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}`).join('\n') || '- none ended this round';
+  return [
+    'You review one round of an Atris campaign. Reply with 2 to 6 short lessons, one per line, each starting with "- ".',
+    'A lesson says what to do differently next round, in plain words. Do not repeat a lesson already listed.',
+    '',
+    `Campaign: ${view.title}`,
+    `Judge: ${view.judge}`,
+    `Judge now: ${view.last_judge ? `${view.last_judge.passed ? 'passed' : 'failed'}${view.last_judge.reading !== null ? ` (reading ${view.last_judge.reading})` : ''}: ${view.answer.text || ''}` : 'never run'}`,
+    `This round: ${summary.kept} kept, ${summary.failed} failed, ${summary.vetoed} could not start, $${summary.spent} spent`,
+    'Missions this round:',
+    missions,
+    '',
+    'Lessons so far:',
+    lessons || '- none yet',
+  ].join('\n');
+}
+
+function makeCadence(root, loop, options = {}, deps = {}) {
+  const store = deps.store || openCampaignStore(root);
+  const log = deps.log || ((line) => console.log(line));
+  const now = deps.now || (() => Date.now());
+  const sleep = deps.sleep || ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const ask = deps.ask;
+  const workMs = parseDuration(options.work, 50 * 60000);
+  const breakMs = parseDuration(options.break, 10 * 60000);
+  const rounds = Number(options.rounds) > 0 ? Number(options.rounds) : Infinity;
+
+  async function review(id, before) {
+    const after = getCampaign(store, id);
+    const summary = roundSummary(before, after);
+    const lessons = readLessons(root, id, 200);
+    let written = [];
+    if (ask) {
+      const answer = await ask(root, after, reviewPrompt(after, summary, lessons));
+      // A lesson already on file is not written twice.
+      const known = new Set(lessons.split('\n').map((line) => line.trim().toLowerCase()));
+      written = String((answer && answer.text) || '').split('\n').map((line) => line.trim())
+        .filter((line) => line.startsWith('- ') && !known.has(line.toLowerCase())).slice(0, 6);
+    }
+    const file = lessonsPath(root, id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (!fs.existsSync(file)) fs.writeFileSync(file, `# Lessons: ${after.title}\n\nWritten by the owner at each review; the next round plans from them.\n`);
+    const stamp = new Date(now()).toISOString().slice(0, 16).replace('T', ' ');
+    const header = `\n## ${stamp}: ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent\n`;
+    fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
+    return { summary, lessons: written };
+  }
+
+  async function run(id) {
+    let round = 0;
+    let last = { reason: 'not started' };
+    while (round < rounds) {
+      round += 1;
+      const before = getCampaign(store, id);
+      const until = now() + workMs;
+      log(`round ${round}: working until ${new Date(until).toISOString().slice(11, 16)}`);
+      let stopped = null;
+      while (now() < until) {
+        const result = await loop.step(id);
+        if (result.stop) {
+          stopped = result.reason;
+          break;
+        }
+      }
+      const breakStarted = now();
+      log(`round ${round}: review`);
+      const { summary, lessons } = await review(id, before);
+      log(`  ${summary.kept} kept, ${summary.failed} failed, $${summary.spent} spent; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const view = getCampaign(store, id);
+      last = { reason: stopped || 'work window ended', round };
+      // Finished, out of money, or waiting on a person: no point in another round.
+      if (['done', 'out_of_budget', 'needs_you', 'paused'].includes(view.state) || (stopped && !/missions running|nothing usable/.test(stopped))) {
+        return { rounds: round, reason: stopped || view.state, campaign: view };
+      }
+      const rest = breakMs - (now() - breakStarted);
+      if (round < rounds && rest > 0) await sleep(rest);
+    }
+    return { rounds: round, reason: last.reason, campaign: getCampaign(store, id) };
+  }
+
+  return { run, review };
+}
+
+module.exports = { lessonsPath, makeCadence, parseDuration, readLessons, reviewPrompt };

package/lib/campaign-core.js

@@ -0,0 +1,330 @@
+// Campaign core: fold(events) -> view, decide(view) -> next move.
+// Pure: no I/O, no clock, no network. The rules are the cross-surface
+// contract in test/fixtures/campaign/README.md; every surface's fold must
+// match the golden files there.
+
+'use strict';
+
+const { TIMESTAMP, validateEvent, isHumanActor } = require('./campaign-schema');
+
+function cents(amount) {
+  return Math.floor(amount * 100 + 0.5);
+}
+
+function dollars(value) {
+  return value / 100;
+}
+
+// An instant at full precision: whole seconds since the epoch plus nine
+// fraction digits, so two events a microsecond apart never tie.
+function instant(at) {
+  const [, date, time, fraction = '', zone] = TIMESTAMP.exec(at);
+  return { seconds: Date.parse(`${date}T${time}${zone}`) / 1000, nanos: fraction.padEnd(9, '0') };
+}
+
+function compareEvents(a, b) {
+  const x = instant(a.at);
+  const y = instant(b.at);
+  if (x.seconds !== y.seconds) return x.seconds - y.seconds;
+  if (x.nanos !== y.nanos) return x.nanos < y.nanos ? -1 : 1;
+  if (a.origin !== b.origin) return a.origin < b.origin ? -1 : 1;
+  if (a.seq !== b.seq) return a.seq - b.seq;
+  if (a.id !== b.id) return a.id < b.id ? -1 : 1;
+  return 0;
+}
+
+function seatFrom(seat) {
+  if (typeof seat === 'string') return { member: seat, role: null };
+  return { member: seat.member, role: seat.role === undefined ? null : seat.role };
+}
+
+function addSeat(seats, seat) {
+  if (seats.some((s) => s.member === seat.member && s.role === seat.role)) return;
+  seats.push(seat);
+}
+
+// Statuses only move forward; dropped and vetoed are final.
+const STATUS_RANK = { proposed: 0, claimed: 1, running: 2, ended: 3 };
+
+function moveTo(m, status) {
+  const from = STATUS_RANK[m.status];
+  if (from === undefined || from >= STATUS_RANK[status]) return;
+  m.status = status;
+}
+
+function newMission(id) {
+  return {
+    id, member: null, status: 'proposed', outcome: null, costCents: null,
+    estimate_usd: null, steps: 0, kept: 0, reverted: 0,
+  };
+}
+
+// Returns the folded view, or { error } when the events must be refused.
+function fold(events) {
+  if (!Array.isArray(events)) return { error: 'invalid_event' };
+  for (const event of events) {
+    if (!validateEvent(event).ok) return { error: 'invalid_event' };
+  }
+  const campaignIds = new Set(events.map((e) => e.campaign_id));
+  if (campaignIds.size > 1) return { error: 'mixed_campaigns' };
+
+  const seen = new Set();
+  const unique = [];
+  for (const event of events) {
+    if (seen.has(event.id)) continue;
+    seen.add(event.id);
+    unique.push(event);
+  }
+  const ordered = unique.slice().sort(compareEvents);
+  const start = ordered.find((e) => e.type === 'campaign_started');
+  if (!start) return { error: 'no_start' };
+
+  const s = {
+    finished: null,
+    paused: false,
+    seats: [],
+    bet: null,
+    parent: null,
+    home: start.origin,
+    missions: new Map(),
+    claims: new Map(),
+    reservations: new Map(),
+    totalCents: cents(start.data.budget),
+    spentCents: 0,
+    asks: new Map(),
+    judgeRuns: [],
+    lastEndedPos: -1,
+    judgeSetPos: -1,
+    judge: start.data.judge,
+    lastJudgePos: -1,
+    warnings: [],
+  };
+  const d = start.data;
+  const owner = typeof d.owner === 'string' && d.owner ? d.owner : 'mission-lead';
+  for (const seat of d.seats || []) addSeat(s.seats, seatFrom(seat));
+  if (d.bet) s.bet = { text: d.bet, wrong_if: null };
+
+  const warn = (event, code) => s.warnings.push({ event_id: event.id, code });
+  const mission = (id) => {
+    if (!s.missions.has(id)) s.missions.set(id, newMission(id));
+    return s.missions.get(id);
+  };
+
+  const sequence = [start, ...ordered.filter((e) => e !== start)];
+  sequence.forEach((event, pos) => {
+    const data = event.data;
+    switch (event.type) {
+      case 'campaign_started':
+        if (event !== start) warn(event, 'duplicate_start');
+        break;
+      case 'seat_filled':
+        addSeat(s.seats, { member: data.member, role: data.role });
+        break;
+      case 'bet_set':
+        s.bet = { text: data.bet, wrong_if: data.wrong_if || null };
+        break;
+      case 'judge_set':
+        if (event.actor !== owner && !isHumanActor(event.actor)) {
+          warn(event, 'judge_set_not_owner');
+        } else {
+          s.judge = data.judge;
+          s.judgeSetPos = pos;
+        }
+        break;
+      case 'attached':
+        s.parent = data.parent_id;
+        break;
+      case 'mission_proposed':
+        if (!s.missions.has(data.mission_id)) {
+          const m = mission(data.mission_id);
+          m.member = data.member || null;
+          m.estimate_usd = typeof data.estimate_usd === 'number' ? dollars(cents(data.estimate_usd)) : null;
+        }
+        break;
+      case 'mission_claimed': {
+        const holder = s.claims.get(data.claim_key);
+        const m = mission(data.mission_id);
+        if (holder !== undefined && holder !== data.mission_id) {
+          warn(event, 'duplicate_claim');
+          if (m.status === 'proposed') m.status = 'dropped';
+        } else {
+          s.claims.set(data.claim_key, data.mission_id);
+          moveTo(m, 'claimed');
+        }
+        break;
+      }
+      case 'mission_vetoed': {
+        if (event.actor !== owner && !isHumanActor(event.actor)) {
+          warn(event, 'veto_not_owner');
+          break;
+        }
+        const m = mission(data.mission_id);
+        if (m.status === 'proposed' || m.status === 'claimed') m.status = 'vetoed';
+        break;
+      }
+      case 'mission_started': {
+        const m = mission(data.mission_id);
+        moveTo(m, 'running');
+        if (m.member === null) m.member = data.member;
+        else if (m.member !== data.member) warn(event, 'second_assignee');
+        break;
+      }
+      case 'step':
+      case 'kept':
+      case 'reverted': {
+        const m = mission(data.mission_id);
+        const key = event.type === 'step' ? 'steps' : event.type;
+        m[key] += 1;
+        break;
+      }
+      case 'mission_ended': {
+        const m = mission(data.mission_id);
+        m.status = 'ended';
+        m.outcome = data.outcome;
+        m.costCents = cents(data.cost_usd);
+        s.spentCents += m.costCents;
+        s.reservations.delete(data.mission_id);
+        s.lastEndedPos = pos;
+        break;
+      }
+      case 'budget_reserved': {
+        const m = s.missions.get(data.mission_id);
+        if (!m || m.status !== 'ended') s.reservations.set(data.mission_id, cents(data.amount_usd));
+        break;
+      }
+      case 'budget_released':
+        s.reservations.delete(data.mission_id);
+        break;
+      case 'budget_added':
+        s.totalCents += cents(data.amount_usd);
+        break;
+      case 'judge_ran':
+        s.judgeRuns.push({
+          passed: data.passed,
+          reading: typeof data.reading === 'number' ? data.reading : null,
+          summary: typeof data.summary === 'string' ? data.summary : null,
+          confidence: data.confidence || null,
+          at: event.at,
+        });
+        s.lastJudgePos = pos;
+        if (data.passed && !d.standing && !s.finished) s.finished = 'judge_passed';
+        break;
+      case 'ask_opened':
+        if (!s.asks.has(data.ask_id)) s.asks.set(data.ask_id, { id: data.ask_id, question: data.question, mission_id: data.mission_id || null });
+        break;
+      case 'ask_answered':
+        if (!isHumanActor(event.actor)) warn(event, 'ask_answered_by_agent');
+        else if (!s.asks.has(data.ask_id)) warn(event, 'unknown_ask');
+        else s.asks.delete(data.ask_id);
+        break;
+      case 'paused':
+        s.paused = true;
+        break;
+      case 'resumed':
+        s.paused = false;
+        break;
+      case 'stopped':
+        if (!s.finished) s.finished = 'stopped';
+        break;
+      case 'home_moved':
+        s.home = data.to;
+        break;
+      case 'done':
+        if (!isHumanActor(event.actor)) warn(event, 'done_without_judge');
+        else if (!s.finished) s.finished = 'done_by_human';
+        break;
+      default:
+        break;
+    }
+  });
+
+  const missions = [...s.missions.values()];
+  let state;
+  let stopReason = null;
+  if (s.finished) {
+    state = 'done';
+    stopReason = s.finished;
+  } else if (s.spentCents >= s.totalCents) {
+    state = 'out_of_budget';
+    stopReason = 'budget_spent';
+  } else if (s.paused) {
+    state = 'paused';
+  } else if (s.asks.size > 0) {
+    state = 'needs_you';
+  } else if (missions.some((m) => m.status === 'running')) {
+    state = 'running';
+  } else if (missions.some((m) => m.status === 'proposed' || m.status === 'claimed')) {
+    state = 'queued';
+  } else {
+    state = 'resting';
+  }
+
+  const runs = s.judgeRuns;
+  const latest = runs.length ? runs[runs.length - 1] : null;
+  let confidence = 'open';
+  if (latest && s.finished === 'judge_passed') {
+    confidence = 'answered';
+  } else if (latest && latest.passed) {
+    let streak = 0;
+    for (let i = runs.length - 1; i >= 0 && runs[i].passed; i--) streak++;
+    confidence = streak >= 3 ? 'stronger' : 'leaning';
+  } else if (latest) {
+    confidence = latest.confidence || 'open';
+  }
+
+  const reservedCents = [...s.reservations.values()].reduce((sum, value) => sum + value, 0);
+  return {
+    id: start.campaign_id,
+    title: d.title,
+    judge: s.judge,
+    owner,
+    standing: d.standing === true,
+    bet: s.bet,
+    parent: s.parent,
+    home: s.home,
+    created_from: d.created_from === undefined ? null : d.created_from,
+    seats: s.seats,
+    state,
+    stop_reason: stopReason,
+    answer: { text: latest ? latest.summary : null, confidence },
+    budget: {
+      total: dollars(s.totalCents),
+      spent: dollars(s.spentCents),
+      reserved: dollars(reservedCents),
+      available: dollars(s.totalCents - s.spentCents - reservedCents),
+    },
+    asks: [...s.asks.values()],
+    missions: missions.map((m) => ({
+      id: m.id,
+      member: m.member,
+      status: m.status,
+      outcome: m.outcome,
+      cost_usd: m.costCents === null ? null : dollars(m.costCents),
+      estimate_usd: m.estimate_usd,
+      steps: m.steps,
+      kept: m.kept,
+      reverted: m.reverted,
+    })),
+    judge_runs: runs.length,
+    judge_due: runs.length === 0 || Math.max(s.lastEndedPos, s.judgeSetPos) > s.lastJudgePos,
+    last_judge: latest ? { passed: latest.passed, reading: latest.reading, at: latest.at } : null,
+    warnings: s.warnings,
+  };
+}
+
+function decide(view) {
+  if (view.state === 'done') return { action: 'none', reason: 'finished' };
+  if (view.state === 'out_of_budget') return { action: 'none', reason: 'budget spent' };
+  if (view.state === 'paused') return { action: 'none', reason: 'paused' };
+  if (view.asks.length > 0) return { action: 'wait', reason: 'open asks', asks: view.asks.map((a) => a.id) };
+  if (view.judge_due) return { action: 'run_judge' };
+  const claimed = view.missions.filter((m) => m.status === 'claimed');
+  const available = cents(view.budget.available);
+  const fits = claimed.find((m) => cents(m.estimate_usd || 0) <= available);
+  if (fits) return { action: 'start_mission', mission_id: fits.id };
+  if (claimed.length > 0) return { action: 'wait', reason: 'budget' };
+  if (view.missions.some((m) => m.status === 'running')) return { action: 'wait', reason: 'missions running' };
+  return { action: 'propose', reason: 'no missions queued' };
+}
+
+module.exports = { cents, compareEvents, decide, fold };

package/lib/campaign-holdout.js

@@ -0,0 +1,65 @@
+// Held-out judge data: `atris campaign start --holdout <file>` moves the file
+// out of the repo into the campaign's own folder beside the campaign store, so
+// agents working in the checkout never read it. The judge finds it through
+// ATRIS_CAMPAIGN_HOLDOUT, and any of its lines the judge echoes are scrubbed
+// before the reading is stored, so show and export cannot print them.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MASK = '[held out]';
+
+function holdoutDir(root, campaignId) {
+  return path.join(root, 'campaigns', campaignId, 'holdout');
+}
+
+// The held-out file for a campaign, or null when it has none.
+function findHoldout(root, campaignId) {
+  const dir = holdoutDir(root, campaignId);
+  let names;
+  try { names = fs.readdirSync(dir); } catch { return null; }
+  const name = names.sort().find((n) => fs.statSync(path.join(dir, n)).isFile());
+  return name ? path.join(dir, name) : null;
+}
+
+function moveFile(from, to) {
+  try {
+    fs.renameSync(from, to);
+  } catch (error) {
+    if (error.code !== 'EXDEV') throw error;
+    fs.copyFileSync(from, to);
+    fs.unlinkSync(from);
+  }
+}
+
+// Moves the file in and returns its new path, or { error } in plain words.
+function moveHoldoutIn(root, campaignId, source) {
+  const from = path.resolve(source);
+  if (!fs.existsSync(from) || !fs.statSync(from).isFile()) return { error: `--holdout ${source} is not a file` };
+  const dir = holdoutDir(root, campaignId);
+  fs.mkdirSync(dir, { recursive: true });
+  const to = path.join(dir, path.basename(from));
+  moveFile(from, to);
+  return { path: to, from };
+}
+
+// Puts the file back where it came from, for a start that was refused.
+function moveHoldoutBack(moved) {
+  if (moved && moved.path && fs.existsSync(moved.path) && !fs.existsSync(moved.from)) moveFile(moved.path, moved.from);
+}
+
+// Replaces every held-out line that shows up in text.
+function scrub(text, holdoutPath) {
+  if (typeof text !== 'string' || !text || !holdoutPath) return text;
+  let content;
+  try { content = fs.readFileSync(holdoutPath, 'utf8'); } catch { return text; }
+  const lines = [...new Set(content.split('\n').map((line) => line.trim()).filter((line) => line.length >= 4))];
+  lines.sort((a, b) => b.length - a.length);
+  let out = text;
+  for (const line of lines) out = out.split(line).join(MASK);
+  return out;
+}
+
+module.exports = { findHoldout, holdoutDir, moveHoldoutBack, moveHoldoutIn, scrub };