atris 3.71.2 → 3.72.0

package/lib/campaign-core.js

@@ -60,7 +60,47 @@ function newMission(id) {
 }
 
 // Returns the folded view, or { error } when the events must be refused.
+// A judge reading can carry a saved wait: nothing to do until wake_at, then
+// check the judge again. It rides as extra data on judge_ran so a reader that
+// predates it still folds the campaign. Anything new (a mission, an answer, a
+// new judge, more money, a resume) ends the wait.
+const WAIT_ENDS = new Set(['mission_proposed', 'mission_claimed', 'mission_started', 'mission_ended', 'judge_set', 'ask_answered', 'resumed', 'budget_added']);
+
+function savedWait(data) {
+  const w = data.wait;
+  if (data.passed || !w || !Number.isFinite(w.wake_at) || !(w.wait_ms > 0)) return null;
+  return { wake_at: w.wake_at, wait_ms: w.wait_ms };
+}
+
 function fold(events) {
+  return foldEvents(events);
+}
+
+// Internal consumers can project selected canonical prefix counts in the same
+// traversal. The synchronous projector is trusted and read-only; only its
+// result is retained, so callers need not keep every full historical view.
+function foldWithPrefixes(events, prefixLengths, project = (view) => view) {
+  return collectPrefixes(events, prefixLengths, (state, start, owner, count) =>
+    project(renderView(state, start, owner), count));
+}
+
+// Trace history needs counts, not detached copies of every earlier mission.
+// Use the same transitions and rendering rules, retaining only summary fields.
+function foldWithSummaryPrefixes(events, prefixLengths) {
+  return collectPrefixes(events, prefixLengths, (state, start, owner, count, missionCounts) =>
+    renderView(state, start, owner, missionCounts), true);
+}
+
+function collectPrefixes(events, prefixLengths, project, trackMissionCounts = false) {
+  const requested = new Set(prefixLengths.filter((n) => Number.isSafeInteger(n) && n >= 1));
+  const prefixes = new Map();
+  const view = foldEvents(events, (state, start, owner, count, missionCounts) => {
+    if (requested.has(count)) prefixes.set(count, project(state, start, owner, count, missionCounts));
+  }, trackMissionCounts);
+  return view.error ? view : { view, prefixes };
+}
+
+function foldEvents(events, visit, trackMissionCounts = false) {
   if (!Array.isArray(events)) return { error: 'invalid_event' };
   for (const event of events) {
     if (!validateEvent(event).ok) return { error: 'invalid_event' };
@@ -94,13 +134,18 @@ function fold(events) {
     asks: new Map(),
     judgeRuns: [],
     lastEndedPos: -1,
+    wait: null,
     judgeSetPos: -1,
     judge: start.data.judge,
     lastJudgePos: -1,
+    // Jobs that did real work and ended since the last reading, waiting on it.
+    awaitingReading: [],
     warnings: [],
   };
   const d = start.data;
   const owner = typeof d.owner === 'string' && d.owner ? d.owner : 'mission-lead';
+  const missionCounts = trackMissionCounts
+    ? { proposed: 0, claimed: 0, running: 0, ended: 0, vetoed: 0, dropped: 0 } : null;
   for (const seat of d.seats || []) addSeat(s.seats, seatFrom(seat));
   if (d.bet) s.bet = { text: d.bet, wrong_if: null };
 
@@ -113,6 +158,9 @@ function fold(events) {
   const sequence = [start, ...ordered.filter((e) => e !== start)];
   sequence.forEach((event, pos) => {
     const data = event.data;
+    const missionId = missionCounts ? data.mission_id : undefined;
+    const previousStatus = missionCounts ? s.missions.get(missionId)?.status : undefined;
+    if (WAIT_ENDS.has(event.type)) s.wait = null;
     switch (event.type) {
       case 'campaign_started':
         if (event !== start) warn(event, 'duplicate_start');
@@ -129,6 +177,7 @@ function fold(events) {
         } else {
           s.judge = data.judge;
           s.judgeSetPos = pos;
+          s.awaitingReading = [];
         }
         break;
       case 'attached':
@@ -181,6 +230,8 @@ function fold(events) {
         const m = mission(data.mission_id);
         m.status = 'ended';
         m.outcome = data.outcome;
+        if (data.outcome === 'fault' && typeof data.reason === 'string') m.reason = data.reason;
+        if (m.steps > 0 && data.outcome !== 'kept' && data.outcome !== 'fault') s.awaitingReading.push(m);
         m.costCents = cents(data.cost_usd);
         s.spentCents += m.costCents;
         s.reservations.delete(data.mission_id);
@@ -207,6 +258,11 @@ function fold(events) {
           at: event.at,
         });
         s.lastJudgePos = pos;
+        s.wait = savedWait(data);
+        // A job that worked but stopped short is credited when the very next
+        // reading passes: its work is what moved the check.
+        if (data.passed) for (const m of s.awaitingReading) m.credited = true;
+        s.awaitingReading = [];
         if (data.passed && !d.standing && !s.finished) s.finished = 'judge_passed';
         break;
       case 'ask_opened':
@@ -236,9 +292,22 @@ function fold(events) {
       default:
         break;
     }
+    if (missionCounts) {
+      const status = s.missions.get(missionId)?.status;
+      if (status !== previousStatus) {
+        if (previousStatus !== undefined) missionCounts[previousStatus]--;
+        if (status !== undefined) missionCounts[status]++;
+      }
+    }
+    if (visit) visit(s, start, owner, pos + 1, missionCounts);
   });
 
-  const missions = [...s.missions.values()];
+  return renderView(s, start, owner);
+}
+
+function renderView(s, start, owner, missionCounts = null) {
+  const d = start.data;
+  const missions = missionCounts ? null : [...s.missions.values()];
   let state;
   let stopReason = null;
   if (s.finished) {
@@ -251,9 +320,9 @@ function fold(events) {
     state = 'paused';
   } else if (s.asks.size > 0) {
     state = 'needs_you';
-  } else if (missions.some((m) => m.status === 'running')) {
+  } else if (missionCounts ? missionCounts.running > 0 : missions.some((m) => m.status === 'running')) {
     state = 'running';
-  } else if (missions.some((m) => m.status === 'proposed' || m.status === 'claimed')) {
+  } else if (missionCounts ? missionCounts.proposed + missionCounts.claimed > 0 : missions.some((m) => m.status === 'proposed' || m.status === 'claimed')) {
     state = 'queued';
   } else {
     state = 'resting';
@@ -266,37 +335,43 @@ function fold(events) {
     confidence = 'answered';
   } else if (latest && latest.passed) {
     let streak = 0;
-    for (let i = runs.length - 1; i >= 0 && runs[i].passed; i--) streak++;
+    for (let i = runs.length - 1; i >= 0 && streak < 3 && 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);
+  const budget = {
+    total: dollars(s.totalCents),
+    spent: dollars(s.spentCents),
+    reserved: dollars(reservedCents),
+    available: dollars(s.totalCents - s.spentCents - reservedCents),
+  };
+  if (missionCounts) {
+    return { state, confidence, judge_runs: runs.length, budget, mission_counts: { ...missionCounts }, open_asks: s.asks.size };
+  }
   return {
     id: start.campaign_id,
     title: d.title,
     judge: s.judge,
     owner,
     standing: d.standing === true,
-    bet: s.bet,
+    bet: s.bet ? { ...s.bet } : null,
     parent: s.parent,
     home: s.home,
     // Only when the start event names one, so the shared golden views stay as
     // pinned; no basis means the person's own engines.
     ...(d.basis === 'atris_cloud' || d.basis === 'own_engines' ? { basis: d.basis } : {}),
     created_from: d.created_from === undefined ? null : d.created_from,
-    seats: s.seats,
+    seats: s.seats.map((seat) => ({ ...seat })),
     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()],
+    budget,
+    asks: [...s.asks.values()].map((ask) => ({ ...ask })),
+    // Only while a wait is saved, so the shared golden views stay as pinned.
+    ...(s.wait ? { next_move: { action: 'wait', reason: 'waiting on the world', ...s.wait } } : {}),
     missions: missions.map((m) => ({
       id: m.id,
       member: m.member,
@@ -307,11 +382,13 @@ function fold(events) {
       steps: m.steps,
       kept: m.kept,
       reverted: m.reverted,
+      ...(m.reason ? { reason: m.reason } : {}),
+      ...(m.credited ? { credited: true } : {}),
     })),
     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,
+    warnings: s.warnings.map((warning) => ({ ...warning })),
   };
 }
 
@@ -319,9 +396,13 @@ 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) };
+  // An open ask holds only the mission it names. When every claimed mission is
+  // held, the campaign waits for the person; an ask that names no mission holds nothing.
+  const held = new Set(view.asks.map((a) => a.mission_id).filter(Boolean));
+  const queued = view.missions.filter((m) => m.status === 'claimed');
+  const claimed = queued.filter((m) => !held.has(m.id));
+  if (queued.length > 0 && claimed.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 };
@@ -338,4 +419,4 @@ function paysDollars(view) {
   return Boolean(view && view.basis === 'atris_cloud');
 }
 
-module.exports = { cents, compareEvents, decide, fold, paysDollars };
+module.exports = { cents, compareEvents, decide, fold, foldWithPrefixes, foldWithSummaryPrefixes, paysDollars };

package/lib/campaign-keep.js

@@ -0,0 +1,91 @@
+// atris campaign keep: a one-minute timer that runs `atris campaign wake`,
+// so a campaign's promise to check again holds while no terminal is open
+// (atris/features/campaign/promise.md). launchd on macOS, cron elsewhere.
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MARKER = 'ATRIS_CAMPAIGN_WAKE';
+
+function xml(text) {
+  return String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+function shellQuote(text) {
+  return `'${String(text).replace(/'/g, `'\\''`)}'`;
+}
+
+// One timer per checkout: the label and marker carry a short hash of its root.
+function planKeep({ root, home, platform = process.platform, homeDir = os.homedir(), nodeBin = 'node', atrisBin, envPath = process.env.PATH || '' }) {
+  const slot = crypto.createHash('sha256').update(root).digest('hex').slice(0, 8);
+  // node by name on the saved PATH, so upgrading node does not break the timer.
+  const command = ['/usr/bin/env', nodeBin, atrisBin, 'campaign', 'wake', '--json'];
+  const logPath = path.join(home, 'campaign-wake.log');
+  const base = { root, slot, log_path: logPath, command: command.join(' '), every_seconds: 60 };
+  if (platform === 'darwin') {
+    const label = `ai.atris.campaign-wake.${slot}`;
+    const file = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
+    const contents = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>${command.map((part) => `<string>${xml(part)}</string>`).join('')}</array>
+  <key>WorkingDirectory</key><string>${xml(root)}</string>
+  <key>EnvironmentVariables</key>
+  <dict><key>PATH</key><string>${xml(envPath)}</string><key>ATRIS_SKIP_UPDATE_CHECK</key><string>1</string></dict>
+  <key>StartInterval</key><integer>60</integer>
+  <key>StandardOutPath</key><string>${xml(logPath)}</string>
+  <key>StandardErrorPath</key><string>${xml(logPath)}</string>
+</dict>
+</plist>
+`;
+    return { ...base, kind: 'launchd', label, file, contents };
+  }
+  const marker = `${MARKER}_${slot}`;
+  const line = `* * * * * cd ${shellQuote(root)} && PATH=${shellQuote(envPath)} ATRIS_SKIP_UPDATE_CHECK=1 ${command.map(shellQuote).join(' ')} >> ${shellQuote(logPath)} 2>&1 # ${marker}`;
+  return { ...base, kind: 'cron', marker, crontab_line: line };
+}
+
+function withoutMarker(crontab, marker) {
+  return String(crontab || '').split('\n').filter((l) => l.trim() && !l.includes(marker)).join('\n');
+}
+
+// Replaces any timer this checkout already has. Returns { ok, error? }.
+function installKeep(plan, { spawn = spawnSync, uid = process.getuid && process.getuid() } = {}) {
+  fs.mkdirSync(path.dirname(plan.log_path), { recursive: true });
+  if (plan.kind === 'launchd') {
+    fs.mkdirSync(path.dirname(plan.file), { recursive: true });
+    fs.writeFileSync(plan.file, plan.contents, 'utf8');
+    spawn('launchctl', ['bootout', `gui/${uid}/${plan.label}`], { encoding: 'utf8', timeout: 10000 });
+    const r = spawn('launchctl', ['bootstrap', `gui/${uid}`, plan.file], { encoding: 'utf8', timeout: 10000 });
+    return r.status === 0 ? { ok: true } : { ok: false, error: `launchctl bootstrap failed: ${String(r.stderr || r.stdout || '').trim()}` };
+  }
+  const existing = spawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  const kept = withoutMarker(existing.status === 0 ? existing.stdout : '', plan.marker);
+  const r = spawn('crontab', ['-'], { input: `${kept ? `${kept}\n` : ''}${plan.crontab_line}\n`, encoding: 'utf8', timeout: 10000 });
+  return r.status === 0 ? { ok: true } : { ok: false, error: `crontab failed: ${String(r.stderr || r.stdout || '').trim()}` };
+}
+
+function removeKeep(plan, { spawn = spawnSync, uid = process.getuid && process.getuid() } = {}) {
+  if (plan.kind === 'launchd') {
+    spawn('launchctl', ['bootout', `gui/${uid}/${plan.label}`], { encoding: 'utf8', timeout: 10000 });
+    const had = fs.existsSync(plan.file);
+    if (had) fs.unlinkSync(plan.file);
+    return { ok: true, removed: had };
+  }
+  const existing = spawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  const prior = existing.status === 0 ? String(existing.stdout || '') : '';
+  if (!prior.includes(plan.marker)) return { ok: true, removed: false };
+  const kept = withoutMarker(prior, plan.marker);
+  const r = spawn('crontab', ['-'], { input: kept ? `${kept}\n` : '', encoding: 'utf8', timeout: 10000 });
+  return r.status === 0 ? { ok: true, removed: true } : { ok: false, error: `crontab failed: ${String(r.stderr || r.stdout || '').trim()}` };
+}
+
+module.exports = { MARKER, installKeep, planKeep, removeKeep };

package/lib/campaign-lanes.js

@@ -32,15 +32,20 @@ function approvedLanes(events) {
   return lanes;
 }
 
-// True when this campaign already has an open ask for the lane, so the loop asks once.
-function laneAskOpen(events, lane) {
-  const open = new Set();
+// Lanes with an open ask in this campaign.
+function openLaneAsks(events) {
+  const open = new Map();
   for (const event of events || []) {
     const data = event && event.data ? event.data : {};
-    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane === lane) open.add(data.ask_id);
+    if (event.type === 'ask_opened' && data.kind === LANE_ASK_KIND && data.lane) open.set(data.ask_id, data.lane);
     if (event.type === 'ask_answered') open.delete(data.ask_id);
   }
-  return open.size > 0;
+  return new Set(open.values());
+}
+
+// True when this campaign already has an open ask for the lane, so the loop asks once.
+function laneAskOpen(events, lane) {
+  return openLaneAsks(events).has(lane);
 }
 
 function laneQuestion(lane, member, objective) {
@@ -49,4 +54,4 @@ function laneQuestion(lane, member, objective) {
   return `${member}'s mission touches ${lane}: "${short}". Missions that touch ${lane} wait for you. Let this campaign work on ${lane}? Answer yes to allow it.`;
 }
 
-module.exports = { LANE_ASK_KIND, pausedLane, approvedLanes, laneAskOpen, laneQuestion };
+module.exports = { LANE_ASK_KIND, pausedLane, approvedLanes, laneAskOpen, laneQuestion, openLaneAsks };