atris 3.71.2 → 3.71.3

package/lib/campaign-cadence.js

@@ -11,6 +11,7 @@ const fs = require('fs');
 const path = require('path');
 const { paysDollars } = require('./campaign-core');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
+const { readingKey } = require('./campaign-loop');
 
 const LESSON_LINES_FOR_PLANNING = 30;
 
@@ -26,16 +27,35 @@ 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) {
+function globalLessonsPath(root) {
+  return path.join(root, 'atris', 'campaigns', 'lessons.md');
+}
+
+function parseBulletLines(filePath) {
   try {
-    const text = fs.readFileSync(lessonsPath(root, campaignId), 'utf8');
-    return text.split('\n').filter((line) => line.trim().startsWith('- ')).slice(-lines).join('\n');
+    const text = fs.readFileSync(filePath, 'utf8');
+    return text.split('\n').filter((line) => line.trim().startsWith('- '));
   } catch {
-    return '';
+    return [];
   }
 }
 
+// The newest lessons for the planner: local campaign lessons plus deduplicated
+// cross-campaign RSI lessons so every new campaign inherits earlier lessons.
+function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
+  const local = parseBulletLines(lessonsPath(root, campaignId));
+  const global = parseBulletLines(globalLessonsPath(root));
+  const seen = new Set();
+  const merged = [];
+  for (const line of [...local, ...global]) {
+    const key = line.trim().toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(line);
+  }
+  return merged.slice(-lines).join('\n');
+}
+
 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;
@@ -45,6 +65,12 @@ function roundSummary(before, after) {
   return { kept, failed, vetoed, spent, fresh };
 }
 
+// Nothing finished and the check reads the same: there is nothing to learn.
+function quietRound(before, after, summary) {
+  const key = (v) => (v.last_judge ? readingKey(v.last_judge.passed, v.last_judge.reading, v.answer.text) : null);
+  return !summary.fresh.some((m) => m.status === 'ended' || m.status === 'vetoed') && key(before) === key(after);
+}
+
 // On a subscription the round is told without dollars, since none were paid.
 function roundTally(view, summary) {
   return `${summary.kept} kept, ${summary.failed} failed${paysDollars(view) ? `, $${summary.spent} spent` : ''}`;
@@ -82,9 +108,10 @@ function makeCadence(root, loop, options = {}, deps = {}) {
   async function review(id, before) {
     const after = getCampaign(store, id);
     const summary = roundSummary(before, after);
+    const quiet = quietRound(before, after, summary);
     const lessons = readLessons(root, id, 200);
     let written = [];
-    if (ask) {
+    if (ask && !quiet) {
       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()));
@@ -96,8 +123,10 @@ function makeCadence(root, loop, options = {}, deps = {}) {
     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}: ${roundTally(after, summary)}\n`;
-    fs.appendFileSync(file, `${header}${(written.length ? written : ['- (no review written this round)']).join('\n')}\n`);
-    return { summary, lessons: written, view: after };
+    // A quiet round is noted as plain text, so the planner never reads it as a lesson.
+    const body = quiet ? ['(no review written this round: nothing ended and the reading held)'] : (written.length ? written : ['- (no review written this round)']);
+    fs.appendFileSync(file, `${header}${body.join('\n')}\n`);
+    return { summary, lessons: written, view: after, quiet };
   }
 
   async function run(id) {
@@ -118,8 +147,8 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       }
       const breakStarted = now();
       log(`round ${round}: review`);
-      const { summary, lessons, view: reviewed } = await review(id, before);
-      log(`  ${roundTally(reviewed, summary)}; ${lessons.length} lesson${lessons.length === 1 ? '' : 's'} written`);
+      const { summary, lessons, view: reviewed, quiet } = await review(id, before);
+      log(quiet ? '  nothing new this round; no review' : `  ${roundTally(reviewed, summary)}; ${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.

package/lib/campaign-core.js

@@ -60,7 +60,35 @@ 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) {
+  const requested = new Set(prefixLengths.filter((n) => Number.isSafeInteger(n) && n >= 1));
+  const prefixes = new Map();
+  const view = foldEvents(events, (state, start, owner, count) => {
+    if (requested.has(count)) prefixes.set(count, project(renderView(state, start, owner), count));
+  });
+  return view.error ? view : { view, prefixes };
+}
+
+function foldEvents(events, visit) {
   if (!Array.isArray(events)) return { error: 'invalid_event' };
   for (const event of events) {
     if (!validateEvent(event).ok) return { error: 'invalid_event' };
@@ -94,9 +122,12 @@ 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;
@@ -113,6 +144,7 @@ function fold(events) {
   const sequence = [start, ...ordered.filter((e) => e !== start)];
   sequence.forEach((event, pos) => {
     const data = event.data;
+    if (WAIT_ENDS.has(event.type)) s.wait = null;
     switch (event.type) {
       case 'campaign_started':
         if (event !== start) warn(event, 'duplicate_start');
@@ -129,6 +161,7 @@ function fold(events) {
         } else {
           s.judge = data.judge;
           s.judgeSetPos = pos;
+          s.awaitingReading = [];
         }
         break;
       case 'attached':
@@ -181,6 +214,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 +242,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,8 +276,14 @@ function fold(events) {
       default:
         break;
     }
+    if (visit) visit(s, start, owner, pos + 1);
   });
 
+  return renderView(s, start, owner);
+}
+
+function renderView(s, start, owner) {
+  const d = start.data;
   const missions = [...s.missions.values()];
   let state;
   let stopReason = null;
@@ -279,14 +325,14 @@ function fold(events) {
     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 },
@@ -296,7 +342,9 @@ function fold(events) {
       reserved: dollars(reservedCents),
       available: dollars(s.totalCents - s.spentCents - reservedCents),
     },
-    asks: [...s.asks.values()],
+    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 +355,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 +369,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 +392,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, 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 };