atris 3.71.2 → 3.72.0

package/lib/campaign-run-lock.js

@@ -56,4 +56,12 @@ function acquireRunLock(home, campaignId, { pid = process.pid, host = os.hostnam
   return { ok: false, holder: readHolder(file) };
 }
 
-module.exports = { acquireRunLock, lockPath };
+// Who drives this campaign right now, or null. Same rules as acquireRunLock, nothing written.
+function liveHolder(home, campaignId, { host = os.hostname(), isAlive = alive } = {}) {
+  const holder = readHolder(lockPath(home, campaignId));
+  if (!holder) return null;
+  if (holder.host !== host) return holder;
+  return isAlive(holder.pid) ? holder : null;
+}
+
+module.exports = { acquireRunLock, liveHolder, lockPath };

package/lib/campaign-schedule.js

@@ -0,0 +1,124 @@
+// atris campaign schedule: a person says yes once, and the campaign starts on
+// its own at set times until its budget is spent. The schedule lives beside the
+// campaign's other files, not in its events, so other surfaces fold unchanged.
+// `atris campaign wake` (the keep timer) and `atris campaign tick` fire it.
+// Spec: atris/features/campaign/schedule.md.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MIN = 60 * 1000;
+const DAY_NAMES = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+const DAY_SETS = { daily: [0, 1, 2, 3, 4, 5, 6], weekdays: [1, 2, 3, 4, 5], weekends: [0, 6] };
+const DEFAULT_STEPS = 4;
+
+const HOW = 'say when like "weekdays 09:00", "daily 18:30", "mon,thu 07:00", or "30m" / "2h"';
+
+// "30m", "2h", "daily 09:00", "weekdays 09:00", "mon,wed 14:30", or "09:00"
+// (every day). Clock times are local to the computer that runs the timer.
+function parseEvery(text) {
+  const value = String(text || '').trim().toLowerCase();
+  if (!value) return { error: `a schedule needs a time: ${HOW}` };
+  const interval = /^(\d+)\s*(m|min|mins|minutes?|h|hr|hrs|hours?)$/.exec(value);
+  if (interval) {
+    const ms = Number(interval[1]) * (interval[2].startsWith('h') ? 60 : 1) * MIN;
+    if (ms < MIN) return { error: 'a schedule runs at most once a minute' };
+    return { rule: { kind: 'interval', ms }, every: value };
+  }
+  const parts = value.split(/\s+/);
+  const clock = /^(\d{1,2}):(\d{2})$/.exec(parts[parts.length - 1]);
+  if (!clock || parts.length > 2) return { error: `cannot read "${text}": ${HOW}` };
+  const hour = Number(clock[1]);
+  const minute = Number(clock[2]);
+  if (hour > 23 || minute > 59) return { error: `"${parts[parts.length - 1]}" is not a time of day` };
+  let days = DAY_SETS.daily;
+  if (parts.length === 2) {
+    days = DAY_SETS[parts[0]];
+    if (!days) {
+      days = [];
+      for (const name of parts[0].split(',')) {
+        const day = DAY_NAMES.indexOf(name.slice(0, 3));
+        if (day < 0 || (name.length > 3 && !name.startsWith(DAY_NAMES[day]))) return { error: `"${name}" is not a day: ${HOW}` };
+        if (!days.includes(day)) days.push(day);
+      }
+      days.sort();
+    }
+  }
+  return { rule: { kind: 'clock', days, hour, minute }, every: value };
+}
+
+// The next slot after `after` (epoch ms), on a whole minute so it is due at the
+// minute it is shown, and the one-minute timer never runs it a minute late.
+function nextAt(rule, after) {
+  if (rule.kind === 'interval') return Math.floor((after + rule.ms) / MIN) * MIN;
+  const at = new Date(after);
+  at.setSeconds(0, 0);
+  at.setHours(rule.hour, rule.minute);
+  for (let i = 0; i < 8; i++) {
+    if (at.getTime() > after && rule.days.includes(at.getDay())) return at.getTime();
+    at.setDate(at.getDate() + 1);
+    at.setHours(rule.hour, rule.minute, 0, 0);
+  }
+  return null;
+}
+
+function scheduleFile(home, campaignId) {
+  return path.join(home, 'campaigns', campaignId, 'schedule.json');
+}
+
+function readSchedule(home, campaignId) {
+  if (!home) return null;
+  try {
+    const saved = JSON.parse(fs.readFileSync(scheduleFile(home, campaignId), 'utf8'));
+    return saved && saved.rule && Number.isFinite(saved.next_at) ? saved : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeSchedule(home, campaignId, schedule) {
+  const file = scheduleFile(home, campaignId);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(schedule, null, 2)}\n`);
+  fs.renameSync(tmp, file);
+  return schedule;
+}
+
+function saveSchedule(home, campaignId, { every, rule, steps = DEFAULT_STEPS, by, now }) {
+  return writeSchedule(home, campaignId, {
+    campaign_id: campaignId, every, rule, steps, approved_by: by,
+    approved_at: new Date(now).toISOString(), last_fired_at: null, next_at: nextAt(rule, now),
+  });
+}
+
+function removeSchedule(home, campaignId) {
+  const file = scheduleFile(home, campaignId);
+  if (!fs.existsSync(file)) return false;
+  fs.unlinkSync(file);
+  return true;
+}
+
+function isDue(schedule, now) {
+  return Boolean(schedule) && now >= schedule.next_at;
+}
+
+// Use up the slot before the run starts, so a run that crashes does not fire
+// again every minute. A slot missed while the computer slept fires once.
+function markFired(home, campaignId, schedule, now) {
+  return writeSchedule(home, campaignId, { ...schedule, last_fired_at: new Date(now).toISOString(), next_at: nextAt(schedule.rule, now) });
+}
+
+function whenText(ms) {
+  const at = new Date(ms);
+  const day = at.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' });
+  return `${day} ${String(at.getHours()).padStart(2, '0')}:${String(at.getMinutes()).padStart(2, '0')}`;
+}
+
+function describe(schedule) {
+  return `${schedule.every}, up to ${schedule.steps} step${schedule.steps === 1 ? '' : 's'} each time; next ${whenText(schedule.next_at)}`;
+}
+
+module.exports = { DEFAULT_STEPS, describe, isDue, markFired, nextAt, parseEvery, readSchedule, removeSchedule, saveSchedule, scheduleFile, whenText };

package/lib/campaign-schema.js

@@ -32,7 +32,9 @@ const STATES = Object.freeze([
 
 const STOP_REASONS = Object.freeze(['judge_passed', 'stopped', 'done_by_human', 'budget_spent']);
 
-const MISSION_OUTCOMES = Object.freeze(['kept', 'reverted', 'failed']);
+// A fault is a job that never ran (engine missing, crash before the first
+// step): the setup broke, not the work.
+const MISSION_OUTCOMES = Object.freeze(['kept', 'reverted', 'failed', 'fault']);
 
 // What a person or agent writes. Everything else is folded from events.
 const CAMPAIGN_FIELDS = Object.freeze({

package/lib/campaign-store.js

@@ -267,6 +267,20 @@ function createMemoryStore(options = {}) {
   const missions = new Map();
   const seqByOrigin = new Map();
   const meta = new Map();
+  const eventIds = new Set();
+  const firstByOriginSeq = new Map();
+  let lookupIndexed = true;
+  const { isProxy } = require('node:util').types;
+  const indexable = (event) => {
+    // Reflection must not add caller Proxy traps or evaluate any getters.
+    if (isProxy(event) || event === null || typeof event !== 'object' || Object.getPrototypeOf(event) !== Object.prototype) return false;
+    const id = Object.getOwnPropertyDescriptor(event, 'id');
+    const origin = Object.getOwnPropertyDescriptor(event, 'origin');
+    const seq = Object.getOwnPropertyDescriptor(event, 'seq');
+    return id && Object.hasOwn(id, 'value') && typeof id.value === 'string'
+      && origin && Object.hasOwn(origin, 'value') && typeof origin.value === 'string'
+      && seq && Object.hasOwn(seq, 'value') && Number.isInteger(seq.value) && seq.value >= 1;
+  };
 
   const clone = (value) => JSON.parse(JSON.stringify(value));
   const count = (campaignId) => events.filter((e) => e.campaign_id === campaignId).length;
@@ -283,6 +297,18 @@ function createMemoryStore(options = {}) {
     if (missionId && !missions.has(missionId)) missions.set(missionId, event.campaign_id);
     seqByOrigin.set(event.origin, Math.max(seqByOrigin.get(event.origin) || 0, event.seq));
     events.push(clone(event));
+    if (lookupIndexed) {
+      // Index the row actually stored, after any reentrant toJSON commits.
+      const stored = events[events.length - 1];
+      if (!indexable(stored)) {
+        lookupIndexed = false;
+      } else {
+        eventIds.add(stored.id);
+        let sequences = firstByOriginSeq.get(stored.origin);
+        if (!sequences) firstByOriginSeq.set(stored.origin, sequences = new Map());
+        if (!sequences.has(stored.seq)) sequences.set(stored.seq, stored);
+      }
+    }
   };
 
   return {
@@ -306,8 +332,14 @@ function createMemoryStore(options = {}) {
     ingest(event) {
       const check = validateEvent(event);
       if (!check.ok) throw storeError('invalid_event', `invalid ${event && event.type}: ${check.errors.join(', ')}`);
-      if (events.some((e) => e.id === event.id)) return false;
-      const clash = events.find((e) => e.origin === event.origin && e.seq === event.seq);
+      let clash;
+      if (lookupIndexed && indexable(event)) {
+        if (eventIds.has(event.id)) return false;
+        clash = firstByOriginSeq.get(event.origin)?.get(event.seq);
+      } else {
+        if (events.some((e) => e.id === event.id)) return false;
+        clash = events.find((e) => e.origin === event.origin && e.seq === event.seq);
+      }
       if (clash) throw storeError('seq_conflict', `origin ${event.origin} seq ${event.seq} is already ${clash.id}`);
       checkMission(event);
       if (event.type === 'campaign_started' && !campaigns.has(event.campaign_id)) campaigns.set(event.campaign_id, event.at);

package/lib/campaign-trace.js

@@ -7,7 +7,7 @@
 'use strict';
 
 const crypto = require('crypto');
-const { compareEvents, fold } = require('./campaign-core');
+const { compareEvents, fold, foldWithSummaryPrefixes } = require('./campaign-core');
 const { judgeReading } = require('./campaign-reading');
 
 const SCHEMA = 'atris.campaign.trace';
@@ -18,7 +18,7 @@ const PRIVACY = {
   full: 'Full: includes titles, objectives, verify commands, the judge command, judge summaries and output tails, and ask text. Export this only for your own data, or with the written consent of everyone in the campaign.',
 };
 
-const REWARD = 'reward = reading_after - reading_before, where a reading is the judge score in [0, 1] from the judge runs on either side of the mission. Missions that ended between the same two judge runs form a batch and split the change equally.';
+const REWARD = 'reward = reading_after - reading_before, where a reading is the judge score in [0, 1] from the judge runs on either side of the mission. An accepted judge reset between those runs makes the comparison unknown. Missions that ended between the same two judge runs form a batch; eligible missions split the change equally. Setup faults never ran, so they have no work reward and take no share of that change.';
 
 function round(value, places = 6) {
   const scale = 10 ** places;
@@ -55,16 +55,14 @@ function foldOrder(events) {
 }
 
 function compactState(view, run) {
-  const missions = { proposed: 0, claimed: 0, running: 0, ended: 0, vetoed: 0, dropped: 0 };
-  for (const m of view.missions) missions[m.status] = (missions[m.status] || 0) + 1;
   return {
     state: view.state,
     reading: readingOf(run).value,
-    confidence: view.answer.confidence,
+    confidence: view.confidence,
     judge_runs: view.judge_runs,
     budget: view.budget,
-    missions,
-    open_asks: view.asks.length,
+    missions: view.mission_counts,
+    open_asks: view.open_asks,
   };
 }
 
@@ -84,14 +82,20 @@ function buildTrace(events, options = {}) {
 
   const missions = new Map();
   const judgeRuns = [];
+  const judgeChanges = [];
+  // Use the fold's authorization decision rather than a second owner rule.
+  const ignoredJudgeChanges = new Set(final.warnings
+    .filter(warning => warning.code === 'judge_set_not_owner')
+    .map(warning => warning.event_id));
   const asks = new Map();
   const info = (id) => {
-    if (!missions.has(id)) missions.set(id, { id, firstPos: null, endPos: null, objective: null, verify: null, member: null, engine: null, kind: 'mission', estimate: null, ticks: 0, uncostedTicks: 0, endData: null, asks: [] });
+    if (!missions.has(id)) missions.set(id, { id, firstPos: null, endPos: null, objective: null, verify: null, member: null, engine: null, executionEngines: [], kind: 'mission', estimate: null, ticks: 0, uncostedTicks: 0, endData: null, asks: [] });
     return missions.get(id);
   };
 
   sequence.forEach((event, pos) => {
     const d = event.data;
+    if (event.type === 'judge_set' && !ignoredJudgeChanges.has(event.id)) judgeChanges.push(pos);
     if (event.type === 'judge_ran') {
       judgeRuns.push({ pos, at: event.at, passed: d.passed, reading: d.reading, summary: d.summary || null, outputTail: d.output_tail || null });
       return;
@@ -117,8 +121,10 @@ function buildTrace(events, options = {}) {
     if (typeof d.engine === 'string' && event.type === 'mission_started' && d.kind === 'plan') m.engine = d.engine;
     if (typeof d.estimate_usd === 'number' && m.estimate === null) m.estimate = d.estimate_usd;
     if (event.type === 'mission_started' && d.kind === 'plan') m.kind = 'plan';
+    if (event.type === 'mission_started' && !m.startedAt) m.startedAt = event.at;
     if (event.type === 'step') {
       m.ticks += 1;
+      if (d.kind !== 'plan') m.executionEngines.push(typeof d.engine === 'string' && d.engine ? d.engine : null);
       if (!(typeof d.cost_usd === 'number' && Number.isFinite(d.cost_usd) && d.cost_usd >= 0)) m.uncostedTicks += 1;
     }
     if (event.type === 'mission_ended' && m.endPos === null) {
@@ -129,24 +135,53 @@ function buildTrace(events, options = {}) {
   });
   for (const ask of asks.values()) if (ask.mission_id && missions.has(ask.mission_id)) missions.get(ask.mission_id).asks.push(ask);
 
-  // The view as it stood just before a position, folded once per position.
-  const prefixViews = new Map();
-  const viewBefore = (pos) => {
-    if (!prefixViews.has(pos)) prefixViews.set(pos, fold(sequence.slice(0, Math.max(1, pos))));
-    return prefixViews.get(pos);
-  };
+  const ended = [...missions.values()].filter((m) => m.endPos !== null).sort((a, b) => a.endPos - b.endPos);
+  // Reuse one event traversal and retain only the compact state needed for
+  // ended missions. Reading lookup below still uses the original position.
+  const prefixStates = ended.length
+    ? foldWithSummaryPrefixes(sequence, ended.map((m) => Math.max(1, m.firstPos === null ? m.endPos : m.firstPos))).prefixes
+    : new Map();
   const lastRunBefore = (pos) => {
-    let found = null;
-    for (const run of judgeRuns) if (run.pos < pos) found = run;
-    return found;
+    let lo = 0;
+    let hi = judgeRuns.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (judgeRuns[mid].pos < pos) lo = mid + 1;
+      else hi = mid;
+    }
+    return judgeRuns[lo - 1] || null;
+  };
+  const firstRunAfter = (pos) => {
+    let lo = 0;
+    let hi = judgeRuns.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (judgeRuns[mid].pos <= pos) lo = mid + 1;
+      else hi = mid;
+    }
+    return judgeRuns[lo] || null;
+  };
+  const judgeChangedBetween = (beforePos, afterPos) => {
+    let lo = 0;
+    let hi = judgeChanges.length;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (judgeChanges[mid] <= beforePos) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo < judgeChanges.length && judgeChanges[lo] < afterPos;
   };
-  const firstRunAfter = (pos) => judgeRuns.find((run) => run.pos > pos) || null;
 
   // Where the campaign finished, if it did: the first position whose prefix is done.
   let finishPos = null;
   if (final.state === 'done') {
     let lo = 0;
     let hi = sequence.length - 1;
+    for (const [count, snapshot] of prefixStates) {
+      if (snapshot.state === 'done') { hi = count - 1; break; }
+      lo = count;
+    }
+
     while (lo < hi) {
       const mid = Math.floor((lo + hi) / 2);
       if (fold(sequence.slice(0, mid + 1)).state === 'done') hi = mid;
@@ -156,7 +191,7 @@ function buildTrace(events, options = {}) {
   }
 
   const finalMissions = new Map(final.missions.map((m) => [m.id, m]));
-  const ended = [...missions.values()].filter((m) => m.endPos !== null).sort((a, b) => a.endPos - b.endPos);
+  const outcomeOf = (m) => (finalMissions.get(m.id) || {}).outcome || m.endData.outcome;
 
   // A batch: missions that ended between the same two judge runs.
   const batches = new Map();
@@ -164,8 +199,10 @@ function buildTrace(events, options = {}) {
     const before = lastRunBefore(m.endPos);
     const after = firstRunAfter(m.endPos);
     const key = `${before ? before.pos : -1}:${after ? after.pos : 'open'}`;
-    if (!batches.has(key)) batches.set(key, { index: batches.size + 1, before, after, missions: [] });
-    batches.get(key).missions.push(m);
+    if (!batches.has(key)) batches.set(key, { index: batches.size + 1, before, after, missions: [], eligible: 0 });
+    const batch = batches.get(key);
+    batch.missions.push(m);
+    if (outcomeOf(m) !== 'fault') batch.eligible += 1;
   }
 
   const memberFor = (member) => (redact && typeof member === 'string' && member.startsWith('human:') ? 'human' : member);
@@ -178,23 +215,31 @@ function buildTrace(events, options = {}) {
     const after = firstRunAfter(m.endPos);
     const batch = batches.get(`${before ? before.pos : -1}:${after ? after.pos : 'open'}`);
     const size = batch.missions.length;
+    const outcome = outcomeOf(m);
+    const judgeChanged = before && after && judgeChangedBetween(before.pos, after.pos);
     const readBefore = readingOf(before);
-    const readAfter = readingOf(after);
+    // A replacement baseline is real campaign state, but cannot score earlier
+    // work. Null also prevents a replacement pass becoming fallback RSI proof.
+    const readAfter = readingOf(judgeChanged ? null : after);
     const delta = readBefore.value !== null && readAfter.value !== null ? readAfter.value - readBefore.value : null;
     const startPos = m.firstPos === null ? m.endPos : m.firstPos;
-    const view = viewBefore(startPos);
     const folded = finalMissions.get(m.id) || {};
     const uncosted = typeof m.endData.uncosted_runs === 'number' ? m.endData.uncosted_runs : m.uncostedTicks;
     let creditNote = null;
-    if (!after) creditNote = 'no judge run after this mission yet, so it has no reward';
+    if (outcome === 'fault') creditNote = 'this mission never ran (setup fault), so it has no work reward and takes no share of the reading change';
+    else if (!after) creditNote = 'no judge run after this mission yet, so it has no reward';
     else if (!before) creditNote = 'no judge run before this mission, so it has no reward';
+    else if (judgeChanged) creditNote = 'the judge changed between readings, so this mission has no comparable reward';
+    else if (batch.eligible < size) creditNote = `one of ${batch.eligible} eligible missions in this batch; setup faults are excluded and the reading change is split equally`;
     else if (size > 1) creditNote = `one of ${size} missions that ended between the same two judge runs; the reading change is split equally`;
 
     const action = {
       mission_id: idFor(m.id),
       kind: m.kind,
       member: memberFor(folded.member || m.member),
-      engine: m.engine || (typeof m.endData.engine === 'string' ? m.endData.engine : null),
+      engine: m.executionEngines.length
+        ? new Set(m.executionEngines).size === 1 ? m.executionEngines[0] : null
+        : m.engine || (typeof m.endData.engine === 'string' ? m.endData.engine : null),
       estimate_usd: m.estimate,
     };
     if (!redact) {
@@ -207,9 +252,9 @@ function buildTrace(events, options = {}) {
       step: i + 1,
       at: m.endAt,
       batch: { index: batch.index, size },
-      state_before: compactState(view, lastRunBefore(startPos)),
+      state_before: compactState(prefixStates.get(Math.max(1, startPos)), lastRunBefore(startPos)),
       action,
-      outcome: folded.outcome || m.endData.outcome,
+      outcome,
       cost_usd: folded.cost_usd === undefined || folded.cost_usd === null ? m.endData.cost_usd : folded.cost_usd,
       ticks: m.ticks,
       uncosted_ticks: uncosted,
@@ -217,12 +262,15 @@ function buildTrace(events, options = {}) {
       reading_before: readBefore.value,
       reading_after: readAfter.value,
       reading_source: readAfter.source,
-      reward: delta === null ? null : round(delta / size),
+      reward: outcome === 'fault' || delta === null ? null : round(delta / batch.eligible),
       credit_note: creditNote,
       done: finishPos !== null && finishPos <= (after ? after.pos : lastPos),
-      judge_passed: after ? after.passed : null,
+      judge_passed: after && !judgeChanged ? after.passed : null,
     };
     if (!redact) {
+      row.started_at = m.startedAt || null;
+      row.receipt_path = typeof m.endData.receipt_path === 'string' ? m.endData.receipt_path : null;
+      row.execution_engines = m.executionEngines;
       row.judge_summary = after ? after.summary : null;
       row.judge_output_tail = after ? after.outputTail : null;
       row.asks = m.asks.map((ask) => ({ question: ask.question, answer: ask.answer }));

package/lib/engine-resource.js

@@ -93,7 +93,11 @@ const SYSTEM_TOOLS = {
 
 function defaultRun(cmd, args) {
   const full = SYSTEM_TOOLS[cmd];
-  return spawnSync(full && fs.existsSync(full) ? full : cmd, args, { encoding: 'utf8', timeout: 3000 });
+  const options = { encoding: 'utf8', timeout: 3000 };
+  // Environment listings grow with local jobs; keep a finite allowance above
+  // Node's default 1 MiB without changing the deadline or failed-read policy.
+  if (cmd === 'ps') options.maxBuffer = 8 * 1024 * 1024;
+  return spawnSync(full && fs.existsSync(full) ? full : cmd, args, options);
 }
 
 function parseFreePct(text) {