atris 3.71.3 → 3.72.0

package/lib/campaign-cadence.js

@@ -34,7 +34,10 @@ function globalLessonsPath(root) {
 function parseBulletLines(filePath) {
   try {
     const text = fs.readFileSync(filePath, 'utf8');
-    return text.split('\n').filter((line) => line.trim().startsWith('- '));
+    return text.split('\n').filter((line) => {
+      const bullet = line.trim();
+      return bullet.startsWith('- ') && bullet !== '- (no review written this round)';
+    });
   } catch {
     return [];
   }
@@ -57,7 +60,12 @@ function readLessons(root, campaignId, lines = LESSON_LINES_FOR_PLANNING) {
 }
 
 function roundSummary(before, after) {
-  const fresh = after.missions.filter((m) => !before.missions.some((b) => b.id === m.id && b.status === m.status));
+  const previous = new Map();
+  for (const { id, status } of before.missions) {
+    if (!previous.has(id)) previous.set(id, new Set());
+    previous.get(id).add(status);
+  }
+  const fresh = after.missions.filter((m) => !previous.get(m.id)?.has(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;
@@ -138,10 +146,12 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       const until = now() + workMs;
       log(`round ${round}: working until ${new Date(until).toISOString().slice(11, 16)}`);
       let stopped = null;
+      let failed = false;
       while (now() < until) {
         const result = await loop.step(id);
         if (result.stop) {
           stopped = result.reason;
+          failed = result.ok === false;
           break;
         }
       }
@@ -150,15 +160,15 @@ function makeCadence(root, loop, options = {}, deps = {}) {
       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 };
+      last = { reason: stopped || 'work window ended', round, failed };
       // 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 };
+        return { ...(failed ? { ok: false } : {}), 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 { ...(last.failed ? { ok: false } : {}), rounds: round, reason: last.reason, campaign: getCampaign(store, id) };
   }
 
   return { run, review };

package/lib/campaign-core.js

@@ -80,15 +80,27 @@ function fold(events) {
 // 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) => {
-    if (requested.has(count)) prefixes.set(count, project(renderView(state, start, owner), count));
-  });
+  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) {
+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' };
@@ -132,6 +144,8 @@ function foldEvents(events, visit) {
   };
   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 };
 
@@ -144,6 +158,8 @@ function foldEvents(events, visit) {
   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':
@@ -276,15 +292,22 @@ function foldEvents(events, visit) {
       default:
         break;
     }
-    if (visit) visit(s, start, owner, pos + 1);
+    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);
   });
 
   return renderView(s, start, owner);
 }
 
-function renderView(s, start, owner) {
+function renderView(s, start, owner, missionCounts = null) {
   const d = start.data;
-  const missions = [...s.missions.values()];
+  const missions = missionCounts ? null : [...s.missions.values()];
   let state;
   let stopReason = null;
   if (s.finished) {
@@ -297,9 +320,9 @@ function renderView(s, start, owner) {
     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';
@@ -312,13 +335,22 @@ function renderView(s, start, owner) {
     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,
@@ -336,12 +368,7 @@ function renderView(s, start, owner) {
     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),
-    },
+    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 } } : {}),
@@ -392,4 +419,4 @@ function paysDollars(view) {
   return Boolean(view && view.basis === 'atris_cloud');
 }
 
-module.exports = { cents, compareEvents, decide, fold, foldWithPrefixes, paysDollars };
+module.exports = { cents, compareEvents, decide, fold, foldWithPrefixes, foldWithSummaryPrefixes, paysDollars };

package/lib/campaign-loop.js

@@ -8,10 +8,11 @@
 const path = require('path');
 const crypto = require('crypto');
 const { spawn } = require('child_process');
-const { decide } = require('./campaign-core');
+const { compareEvents, decide, fold } = require('./campaign-core');
+const { validateEvent } = require('./campaign-schema');
 const { getCampaign, openCampaignStore } = require('./campaign-store');
 const { defaultReserve, missionCost, reconcileCampaign } = require('./campaign-missions');
-const { judgeRanData, latestJudgeOutput } = require('./campaign-reading');
+const { confirmedReading, judgeRanData, latestJudgeOutput } = require('./campaign-reading');
 const { LANE_ASK_KIND, pausedLane, laneAskOpen, laneQuestion, openLaneAsks } = require('./campaign-lanes');
 
 const TERMINAL = new Set(['stopped', 'complete']);
@@ -36,7 +37,7 @@ function proposalId(objective) {
   return `m-${slug || 'mission'}-${crypto.randomBytes(3).toString('hex')}`;
 }
 
-function rankCampaignMembers(view, rsiSummary = null) {
+function rankCampaignMembers(view, rsiSummary = null, events = null) {
   const seats = Array.isArray(view && view.seats) ? view.seats.map((s) => s.member).filter(Boolean) : [];
   const candidates = [...new Set([view && view.owner, ...seats].filter(Boolean))];
   const rsiMap = new Map();
@@ -45,7 +46,7 @@ function rankCampaignMembers(view, rsiSummary = null) {
       if (row && row.member) rsiMap.set(row.member, row);
     }
   }
-  const missions = Array.isArray(view && view.missions) ? view.missions : [];
+  const missions = completionOrderedMissions(view, events);
   const raw = candidates.map((member) => {
     const info = rsiMap.get(member) || null;
     const overall = info && typeof info.overall === 'number' ? info.overall : 75;
@@ -74,11 +75,33 @@ function rankCampaignMembers(view, rsiSummary = null) {
   });
 }
 
+// Callers supply the complete history behind this view. Coverage checks can
+// reject a mismatch, but cannot prove that a partial history is complete.
+function completionOrderedMissions(view, events) {
+  const missions = Array.isArray(view && view.missions) ? view.missions : [];
+  if (!Array.isArray(events)) return missions;
+  const seen = new Set();
+  const ends = new Map();
+  let started = false;
+  for (const event of events) {
+    if (!validateEvent(event).ok || event.campaign_id !== (view && view.id)) return missions;
+    if (seen.has(event.id)) continue;
+    seen.add(event.id);
+    if (event.type === 'campaign_started') started = true;
+    if (event.type !== 'mission_ended') continue;
+    const previous = ends.get(event.data.mission_id);
+    if (!previous || compareEvents(previous, event) < 0) ends.set(event.data.mission_id, event);
+  }
+  const ended = missions.filter((m) => m && m.status === 'ended');
+  if (!started || ends.size !== ended.length || ended.some((m) => !ends.has(m.id) || ends.get(m.id).data.outcome !== m.outcome)) return missions;
+  return ended.sort((a, b) => compareEvents(ends.get(a.id), ends.get(b.id)));
+}
+
 // 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 = '', rsiSummary = null) {
+function proposalPrompt(view, count, judgeOutput = null, lessons = '', rsiSummary = null, events = null) {
   const tried = view.missions.slice(-12).map((m) => `- ${m.id}: ${m.status}${m.outcome ? ` (${m.outcome})` : ''}${m.cost_usd !== null ? `, $${m.cost_usd}` : ''}${typeof m.reward === 'number' ? `, reward ${m.reward >= 0 ? '+' : ''}${m.reward}` : ''}`).join('\n') || '- none yet';
-  const ranked = rankCampaignMembers(view, rsiSummary);
+  const ranked = rankCampaignMembers(view, rsiSummary, events);
   const memberLine = ranked.map((r) => {
     if (r.benched) return `${r.member} (${r.overall} ovr, benched after ${r.consecutiveFailures || 'repeat'} misses)`;
     return rsiSummary ? `${r.member} (${r.overall} ovr, ${r.overallLabel})` : r.member;
@@ -108,7 +131,7 @@ function proposalPrompt(view, count, judgeOutput = null, lessons = '', rsiSummar
   ].filter((line) => line !== '').join('\n');
 }
 
-function parseProposals(text, view, count, rsiSummary = null) {
+function parseProposals(text, view, count, rsiSummary = null, events = null) {
   const match = String(text || '').match(/\[[\s\S]*\]/);
   if (!match) return [];
   let rows;
@@ -118,7 +141,7 @@ function parseProposals(text, view, count, rsiSummary = null) {
     return [];
   }
   if (!Array.isArray(rows)) return [];
-  const ranked = rankCampaignMembers(view, rsiSummary);
+  const ranked = rankCampaignMembers(view, rsiSummary, events);
   const activeMembers = new Set(ranked.filter((r) => !r.benched).map((r) => r.member));
   const fallbackMember = (ranked.find((r) => !r.benched) || ranked[0] || { member: view.owner }).member;
   return rows.slice(0, count)
@@ -195,8 +218,8 @@ function makeLoop(root, options = {}, deps = {}) {
   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 events = store.read(id);
+    const current = events.length ? fold(events) : null;
     let rsiSummary = null;
     try {
       const { missionRewardMap, summarizeStoreRsi } = require('./campaign-rsi');
@@ -208,9 +231,9 @@ function makeLoop(root, options = {}, deps = {}) {
       });
       rsiSummary = summarizeStoreRsi(store);
     } catch {}
-    const prompt = proposalPrompt(current, count, latestJudgeOutput(events), deps.lessons ? deps.lessons(id) : '', rsiSummary);
+    const prompt = proposalPrompt(current, count, latestJudgeOutput(events), deps.lessons ? deps.lessons(id) : '', rsiSummary, events);
     const answer = await ask(root, current, prompt);
-    const proposals = parseProposals(answer.text, current, count, rsiSummary);
+    const proposals = parseProposals(answer.text, current, count, rsiSummary, events);
     // 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 is not failed work: the step saves a
@@ -247,7 +270,12 @@ function makeLoop(root, options = {}, deps = {}) {
       '--max-wall', String(missionMinutes * 60), '--json',
     ]);
     if (started.code !== 0) {
-      const why = (started.out + started.err).trim().split('\n').pop();
+      let why = (started.out + started.err).trim().split('\n').pop();
+      try {
+        const error = JSON.parse(started.out);
+        const detail = [error?.detail, error?.error].find(value => typeof value === 'string' && value.trim());
+        if (detail) why = detail.trim();
+      } catch {}
       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 };
@@ -295,8 +323,10 @@ function makeLoop(root, options = {}, deps = {}) {
 
   // Run the judge and record its reading. waitFor(data) returns how long to
   // wait before the next check (0 for no wait); a passing reading never waits.
+  // A pass that would finish the campaign must pass a second, fresh run first.
   async function readJudge(id, current, waitFor = () => 0) {
-    const reading = await judge(current.judge);
+    const run = () => judge(current.judge);
+    const reading = current.standing ? await run() : await confirmedReading(run);
     const data = judgeRanData(reading);
     const waitMs = data.passed ? 0 : waitFor(data);
     if (waitMs > 0) data.wait = { wake_at: now() + waitMs, wait_ms: waitMs };
@@ -360,6 +390,7 @@ function makeLoop(root, options = {}, deps = {}) {
     const proposals = await propose(id, parallel);
     if (!proposals.length) {
       const data = await readJudge(id, current, () => WAIT_FIRST_MS);
+      if (data.passed) return { stop: false, did: 'judge' };
       const next = data.wait ? `; next check at ${clockTime(data.wait.wake_at)}` : '';
       return { ok: false, stop: true, reason: `${current.owner} proposed nothing usable${next}` };
     }
@@ -380,7 +411,7 @@ function makeLoop(root, options = {}, deps = {}) {
       // 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) };
+      if (result.stop) return { ...(result.ok === false ? { ok: false } : {}), steps: i, reason: result.reason, campaign: view(id) };
     }
     return { steps: maxSteps, reason: `stopped after ${maxSteps} steps`, campaign: view(id) };
   }

package/lib/campaign-reading.js

@@ -136,6 +136,19 @@ function judgeRanData(result) {
   return data;
 }
 
+// One pass can be luck: a flaky test, a race, a grader that rolls dice. A pass
+// only counts when a second, fresh run of the same judge passes too. A failed
+// second run is recorded as the failure it is, naming the pass it overturned.
+async function confirmedReading(run) {
+  const first = await run();
+  if (!first.passed) return first;
+  const second = await run();
+  const seconds = (Number(first.seconds) || 0) + (Number(second.seconds) || 0);
+  if (second.passed) return { ...second, seconds };
+  const said = second.summary || lastSaidLine(second.output_tail) || `exit ${second.exit}`;
+  return { ...second, seconds, summary: `passed once, then failed a fresh run: ${said}` };
+}
+
 // The output_tail of the latest judge run in fold order, or null.
 function latestJudgeOutput(events) {
   const { compareEvents } = require('./campaign-core');
@@ -144,4 +157,4 @@ function latestJudgeOutput(events) {
   return last && typeof last.data.output_tail === 'string' && last.data.output_tail ? last.data.output_tail : null;
 }
 
-module.exports = { judgeReading, judgeRanData, latestJudgeOutput, outputTail };
+module.exports = { confirmedReading, judgeReading, judgeRanData, latestJudgeOutput, outputTail };

package/lib/campaign-rsi.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const { buildTrace } = require('./campaign-trace');
+const { compareEvents, fold } = require('./campaign-core');
 const { getCampaign, listCampaigns, openCampaignStore } = require('./campaign-store');
 const rsiRecord = require('./rsi-record');
 const { verifyCodeProvenance } = require('./mission-code-provenance');
@@ -39,7 +40,7 @@ function dedupeLessons(lines) {
   return out;
 }
 
-function aggregateMembers(missions) {
+function aggregateMembers(missions, failureOrder = missions) {
   const byMember = new Map();
   for (const m of missions) {
     const name = m.member || 'unknown';
@@ -54,6 +55,7 @@ function aggregateMembers(missions) {
         repeat_failures: 0,
          failure_streak: 0,
         reward: 0,
+        reward_micros: 0,
         cost_usd: 0,
         wasted_cost_usd: 0,
         reward_per_dollar: null,
@@ -66,26 +68,31 @@ function aggregateMembers(missions) {
     entry.cost_usd = round(entry.cost_usd + cost, 4);
     if (m.outcome === 'kept') {
       entry.kept += 1;
-      entry.failure_streak = 0;
     } else if (m.outcome) {
       entry.failed += 1;
       if (m.outcome === 'reverted') entry.reverted += 1;
-      entry.failure_streak += 1;
-      if (entry.failure_streak >= 2) entry.repeat_failures += 1;
       entry.wasted_cost_usd = round(entry.wasted_cost_usd + cost, 4);
     }
     if (typeof m.reward === 'number' && Number.isFinite(m.reward)) {
-      entry.reward = round(entry.reward + m.reward, 4);
+      entry.reward_micros += Math.round(m.reward * 1000000);
       if (m.reward > 0) entry.judge_passed += 1;
-    } else if (m.reading_after === 1 && m.outcome === 'kept') {
-      entry.judge_passed += 1;
     }
     if (m.outcome === 'kept' && m.reward !== null && m.reward <= 0) {
       entry.zero_reward_kept += 1;
     }
   }
+  for (const m of failureOrder) {
+    const entry = byMember.get(m.member || 'unknown');
+    if (m.outcome === 'kept') entry.failure_streak = 0;
+    else if (m.outcome) {
+      entry.failure_streak += 1;
+      if (entry.failure_streak >= 2) entry.repeat_failures += 1;
+    }
+  }
   const members = [...byMember.values()].map((entry) => {
-    const { failure_streak, ...clean } = entry;
+    const { failure_streak, reward_micros, ...clean } = entry;
+    // Trace shares have six decimals; round the complete member sum only once.
+    clean.reward = Math.round(reward_micros / 100) / 10000;
     const ovr = computeMemberOverall(clean);
     return {
       ...clean,
@@ -265,7 +272,13 @@ function summarizeStoreRsi(store, campaignId = null) {
   const total_spent_usd = round(summaries.reduce((sum, s) => sum + s.spent_usd, 0), 4);
   const reward_per_dollar = total_spent_usd > 0 ? round(total_reward / total_spent_usd, 4) : null;
   const allMissions = summaries.flatMap((s) => s.missions);
-  const mergedMembers = aggregateMembers(allMissions);
+  // Only streaks change order; totals and the public list use the original list.
+  // Campaign IDs break cross-campaign ties; stable sorting keeps local order.
+  const failureOrder = allMissions.slice().sort((a, b) => compareEvents(
+    { at: a.finished_at, origin: a.campaign_id, seq: 0, id: '' },
+    { at: b.finished_at, origin: b.campaign_id, seq: 0, id: '' }
+  ));
+  const mergedMembers = aggregateMembers(allMissions, failureOrder);
   const dedupedLessons = dedupeLessons(summaries.flatMap((s) => s.lessons));
 
   return {
@@ -535,11 +548,15 @@ function selectNextCampaigns(store, rsiSummary = null) {
   const activeStates = new Set(['queued', 'running', 'resting']);
   const open = listCampaigns(store).filter((v) => v && !v.error && activeStates.has(v.state));
   const rows = open.map((v) => {
-    const trace = summarizeTrace(store.read(v.id));
+    const events = store.read(v.id);
+    const trace = summarizeTrace(events);
     const reading = typeof trace.reading === 'number'
       ? trace.reading
       : (v.last_judge && typeof v.last_judge.reading === 'number' ? v.last_judge.reading : 0);
-    const ranked = rankCampaignMembers(v, rsi);
+    const current = fold(events);
+    const ranked = current.error || current.id !== v.id
+      ? rankCampaignMembers(v, rsi)
+      : rankCampaignMembers(current, rsi, events);
     const benched = ranked.filter((r) => r.benched).map((r) => r.member);
     const warm = ranked.find((r) => !r.benched) || ranked[0] || { member: v.owner, overall: 75 };
     const failedCount = (v.missions || []).filter((m) => m.status === 'ended' && m.outcome !== 'kept').length;

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-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);