atris 3.70.0 → 3.71.1

package/lib/campaign-sync.js

@@ -0,0 +1,302 @@
+// Campaign cloud sync: a campaign on this computer and its copy in the Atris
+// cloud trade events by id, so web and iOS show it and a person's answer from
+// a phone reaches a running loop. Contract: atris/features/campaign/api.md.
+//
+// Push sends the events the cloud lacks; pull ingests the ones this computer
+// lacks (answers and actions from screens). Both are idempotent by event id.
+// A 403 or 409 is the cloud saying no on purpose, so it is reported plainly
+// and never retried.
+//
+// A computer that has never seen the campaign (an Atris cloud computer told to
+// run it) pulls the whole log first, campaign_started before anything else.
+
+'use strict';
+
+const fs = require('fs');
+const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { CAMPAIGN_ID } = require('./campaign-schema');
+
+const PUSH_BATCH = 200;
+const PULL_LIMIT = 500;
+const REQUEST_TIMEOUT_MS = 15000;
+// Only a person's screen may send these to the cloud (api.md, Write). A local
+// copy stays local; a person answers on the phone, the web, or with
+// atris campaign answer, which goes to the cloud for a synced campaign.
+const PERSON_ONLY = new Set(['ask_answered', 'budget_added', 'done']);
+
+const metaKey = (campaignId) => `campaign_sync:${campaignId}`;
+
+function readState(store, campaignId) {
+  const raw = store.getMeta(metaKey(campaignId));
+  if (!raw) return null;
+  try {
+    const state = JSON.parse(raw);
+    return state && typeof state === 'object' ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeState(store, campaignId, state) {
+  store.setMeta(metaKey(campaignId), JSON.stringify(state));
+}
+
+// The cloud link for a campaign, or null when it has never been synced.
+function cloudLink(store, campaignId) {
+  const state = readState(store, campaignId);
+  return state && state.link ? state : null;
+}
+
+function plainError(response) {
+  const status = response && response.status;
+  const said = response && (response.error || (response.data && (response.data.error || response.data.detail)));
+  if (!status) return `could not reach the Atris cloud${said ? ` (${said})` : ''}`;
+  if (status === 401) return 'the Atris cloud did not accept your login. run: atris login';
+  if (status === 403) return `the Atris cloud refused this (403)${said ? `: ${said}` : ''}`;
+  if (status === 409) return `the Atris cloud holds a different event at the same place (409)${said ? `: ${said}` : ''}`;
+  return `the Atris cloud answered ${status}${said ? `: ${said}` : ''}`;
+}
+
+function failure(result, response) {
+  return { ...result, ok: false, status: (response && response.status) || 0, error: plainError(response) };
+}
+
+function tokenFrom(load) {
+  try {
+    const credentials = load();
+    const token = credentials && String(credentials.token || '').trim();
+    return token || null;
+  } catch {
+    return null;
+  }
+}
+
+// Every event the cloud holds for a campaign this computer has never seen,
+// ingested with campaign_started first. Returns { ok, pulled, last_seq } or
+// { ok: false, status, error } with what exactly went wrong.
+async function pullWholeCampaign(store, campaignId, call) {
+  const base = `/campaigns/${encodeURIComponent(campaignId)}`;
+  const incoming = [];
+  let after = 0;
+  for (;;) {
+    const response = await call(`${base}/events?after=${after}&limit=${PULL_LIMIT}`, { method: 'GET' });
+    if (response && response.status === 404) {
+      return { ok: false, status: 404, error: `the Atris cloud has no campaign ${campaignId} for this login, so there is nothing to pull. Start it with --cloud on the computer that has it, or check the login (atris whoami)` };
+    }
+    if (!response || !response.ok) return { ok: false, status: (response && response.status) || 0, error: plainError(response) };
+    const data = response.data || {};
+    const page = (Array.isArray(data.events) ? data.events : []).filter((event) => event && event.campaign_id === campaignId);
+    incoming.push(...page);
+    const seq = Number(data.last_event_seq);
+    if (Number.isInteger(seq) && seq > after) after = seq;
+    if (!Array.isArray(data.events) || data.events.length < PULL_LIMIT) break;
+  }
+  if (!incoming.length) {
+    return { ok: false, status: 404, error: `the Atris cloud has no events for ${campaignId}, so there is nothing to pull. Start it with --cloud on the computer that has it` };
+  }
+  const starts = incoming.filter((event) => event.type === 'campaign_started');
+  if (starts.length !== 1) {
+    return { ok: false, status: 0, error: `the cloud copy of ${campaignId} has ${starts.length} campaign_started events, not 1, so this computer cannot start it` };
+  }
+  let pulled = 0;
+  for (const event of [starts[0], ...incoming.filter((e) => e !== starts[0])]) {
+    try {
+      if (store.ingest(event)) pulled += 1;
+    } catch (error) {
+      return { ok: false, status: 0, error: `cloud event ${event.id} could not be taken in: ${error.message}` };
+    }
+  }
+  return { ok: true, pulled, last_seq: after };
+}
+
+// An Atris cloud computer running a campaign holds a token for that one
+// campaign's sync routes, in a file the backend placed (0600). The path comes
+// in ATRIS_CAMPAIGN_TOKEN_FILE. It is read once and taken out of the
+// environment, so no mission, engine, or child CLI started here inherits it.
+const CAMPAIGN_TOKEN_ENV = 'ATRIS_CAMPAIGN_TOKEN_FILE';
+
+function takeCampaignToken(env = process.env, read = fs.readFileSync) {
+  if (!env || env[CAMPAIGN_TOKEN_ENV] === undefined) return null;
+  const file = String(env[CAMPAIGN_TOKEN_ENV]).trim();
+  delete env[CAMPAIGN_TOKEN_ENV];
+  try {
+    const body = JSON.parse(read(file, 'utf8'));
+    const token = body && typeof body.token === 'string' ? body.token.trim() : '';
+    if (token && CAMPAIGN_ID.test(String(body.campaign_id || ''))) return { campaign_id: body.campaign_id, token };
+  } catch {}
+  return { error: `the campaign token file ${file} could not be read` };
+}
+
+// The token a sync of this campaign uses: the campaign's own token when this
+// computer holds one (never the login, even if that fails), else the login.
+function syncToken(campaignId, deps) {
+  const scoped = deps.campaignToken;
+  if (scoped) {
+    if (scoped.error) return { error: scoped.error };
+    if (scoped.campaign_id !== campaignId) return { error: `the campaign token here is for ${scoped.campaign_id}, not ${campaignId}` };
+    return { token: scoped.token };
+  }
+  const token = tokenFrom(deps.loadCredentials || loadCredentials);
+  return token ? { token } : { error: 'not logged in to Atris. run: atris login' };
+}
+
+// One sync of one campaign. Never throws for cloud trouble; returns
+// { ok, pushed, duplicates, held, pulled, last_seq, link, error?, status? }.
+async function syncCampaign(store, campaignId, deps = {}) {
+  const request = deps.apiRequestJson || apiRequestJson;
+  const now = deps.now || (() => new Date().toISOString());
+  const base = `/campaigns/${encodeURIComponent(campaignId)}`;
+  const state = readState(store, campaignId) || { pushed: 0, last_seq: 0 };
+  // A campaign this computer has never seen is linked only once its pull
+  // works, so a wrong id leaves nothing behind.
+  const firstPull = store.read(campaignId).length === 0;
+  const link = state.link || { url: `${getApiBaseUrl()}${base}`, linked_at: now() };
+  if (!state.link && !firstPull) {
+    // Linked from the first try, so a computer that is offline now keeps
+    // trying on every later run step.
+    state.link = link;
+    writeState(store, campaignId, state);
+  }
+  const result = { ok: true, campaign_id: campaignId, pushed: 0, duplicates: 0, held: 0, pulled: 0, last_seq: state.last_seq || 0, link: link.url };
+
+  const { token, error: tokenError } = syncToken(campaignId, deps);
+  if (!token) return { ...result, ok: false, status: 401, error: tokenError };
+  const call = (path, options) => request(path, { token, retries: 0, timeoutMs: REQUEST_TIMEOUT_MS, ...options });
+
+  if (firstPull) {
+    const whole = await pullWholeCampaign(store, campaignId, call);
+    if (!whole.ok) return { ...result, ok: false, status: whole.status, error: whole.error, first_pull: true };
+    // Everything here came from the cloud, so none of it needs pushing back.
+    state.link = link;
+    state.pushed = store.read(campaignId).length;
+    state.last_seq = whole.last_seq;
+    writeState(store, campaignId, state);
+    result.pulled = whole.pulled;
+    result.first_pull = true;
+  }
+
+  // Push: every local event past the last one the cloud is known to hold.
+  const events = store.read(campaignId);
+  if (!events.length) return { ...result, ok: false, error: `no campaign ${campaignId} on this computer` };
+  const known = new Set();
+  const outgoing = [];
+  for (const event of events.slice(state.pushed || 0)) {
+    if (event.origin === 'cloud') { known.add(event.id); continue; }
+    if (PERSON_ONLY.has(event.type)) { result.held += 1; known.add(event.id); continue; }
+    outgoing.push(event);
+  }
+  for (let i = 0; i < outgoing.length; i += PUSH_BATCH) {
+    const batch = outgoing.slice(i, i + PUSH_BATCH);
+    const response = await call(`${base}/events`, { method: 'POST', body: { events: batch } });
+    if (!response || !response.ok) return failure(result, response);
+    const data = response.data || {};
+    result.pushed += Number(data.accepted) || 0;
+    result.duplicates += Number(data.duplicates) || 0;
+    for (const event of batch) known.add(event.id);
+  }
+
+  // Pull: everything the cloud took in after the last seq seen here.
+  let after = state.last_seq || 0;
+  for (;;) {
+    const response = await call(`${base}/events?after=${after}&limit=${PULL_LIMIT}`, { method: 'GET' });
+    if (!response || !response.ok) {
+      state.pushed = advance(events, state.pushed || 0, known);
+      writeState(store, campaignId, state);
+      return failure(result, response);
+    }
+    const data = response.data || {};
+    const incoming = Array.isArray(data.events) ? data.events : [];
+    for (const event of incoming) {
+      if (!event || event.campaign_id !== campaignId) continue;
+      try {
+        if (store.ingest(event)) result.pulled += 1;
+      } catch (error) {
+        state.pushed = advance(events, state.pushed || 0, known);
+        writeState(store, campaignId, state);
+        return { ...result, ok: false, status: 0, error: `a cloud event could not be taken in: ${error.message}` };
+      }
+      known.add(event.id);
+    }
+    const seq = Number(data.last_event_seq);
+    if (Number.isInteger(seq) && seq > after) after = seq;
+    state.last_seq = after;
+    if (incoming.length < PULL_LIMIT) break;
+  }
+  result.last_seq = after;
+
+  // Everything the cloud now holds, including what was just pulled.
+  state.pushed = advance(store.read(campaignId), state.pushed || 0, known);
+  state.synced_at = now();
+  writeState(store, campaignId, state);
+  return result;
+}
+
+// Move the pushed mark forward over events the cloud is known to hold, and
+// stop at the first one it may not have, so an event written mid-sync is sent
+// next time.
+function advance(events, from, known) {
+  let mark = from;
+  while (mark < events.length && known.has(events[mark].id)) mark += 1;
+  return mark;
+}
+
+// A person's answer or action on a synced campaign goes through the cloud's
+// person routes, then comes back down by pull. Returns { ok, error?, status? }.
+async function sendPersonAction(store, campaignId, action, deps = {}) {
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = tokenFrom(deps.loadCredentials || loadCredentials);
+  if (!token) return { ok: false, status: 401, error: 'not logged in to Atris. run: atris login' };
+  const base = `/campaigns/${encodeURIComponent(campaignId)}`;
+  const route = action.ask_id ? `${base}/asks/${encodeURIComponent(action.ask_id)}/answer` : `${base}/actions`;
+  const body = action.ask_id ? { answer: action.answer } : { action: action.action, amount_usd: action.amount_usd };
+  const response = await request(route, { method: 'POST', token, retries: 0, timeoutMs: REQUEST_TIMEOUT_MS, body });
+  if (!response || !response.ok) return failure({}, response);
+  const synced = await syncCampaign(store, campaignId, deps);
+  return synced.ok ? { ok: true, sync: synced } : { ok: true, sync: synced, warning: synced.error };
+}
+
+// Ask the cloud to run a campaign on the person's Atris computer
+// (POST /campaigns/<id>/run-in-cloud), or read how that run is going
+// (GET /campaigns/<id>/cloud-run). Returns { ok, data } or { ok: false, status, error }.
+const CLOUD_RUN_TIMEOUT_MS = 120000; // waking a computer can take most of a minute
+
+async function runInCloud(campaignId, body, deps = {}) {
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = tokenFrom(deps.loadCredentials || loadCredentials);
+  if (!token) return { ok: false, status: 401, error: 'not logged in to Atris. run: atris login' };
+  const response = await request(`/campaigns/${encodeURIComponent(campaignId)}/run-in-cloud`, {
+    method: 'POST', token, retries: 0, timeoutMs: CLOUD_RUN_TIMEOUT_MS, body,
+  });
+  if (!response || !response.ok) return cloudRunFailure(response);
+  return { ok: true, data: response.data || {} };
+}
+
+async function cloudRunStatus(campaignId, deps = {}) {
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = tokenFrom(deps.loadCredentials || loadCredentials);
+  if (!token) return { ok: false, status: 401, error: 'not logged in to Atris. run: atris login' };
+  const response = await request(`/campaigns/${encodeURIComponent(campaignId)}/cloud-run`, {
+    method: 'GET', token, retries: 0, timeoutMs: REQUEST_TIMEOUT_MS,
+  });
+  if (!response || !response.ok) return cloudRunFailure(response);
+  return { ok: true, data: response.data || {} };
+}
+
+// The run routes answer in plain sentences, so pass the cloud's own words on.
+function cloudRunFailure(response) {
+  const status = (response && response.status) || 0;
+  const said = response && ((response.data && (response.data.error || response.data.detail)) || response.error);
+  if (!status) return { ok: false, status, error: plainError(response) };
+  if (status === 401) return { ok: false, status, error: plainError(response) };
+  if (status === 404 && !(response.data && response.data.error)) {
+    return { ok: false, status, error: 'the Atris cloud does not run campaigns on computers yet (404). Try again after the next backend deploy' };
+  }
+  return { ok: false, status, error: typeof said === 'string' && said ? said : plainError(response) };
+}
+
+// What this CLI can do for an Atris cloud computer; the backend checks it
+// (atris campaign features --json) before it starts a cloud run here.
+const CLOUD_FEATURES = ['cloud_pull', 'campaign_token_file'];
+
+module.exports = { CAMPAIGN_TOKEN_ENV, CLOUD_FEATURES, cloudLink, cloudRunStatus, runInCloud, sendPersonAction, syncCampaign, takeCampaignToken };

package/lib/campaign-trace.js

@@ -0,0 +1,300 @@
+// Campaign traces: a campaign's event log as reinforcement-learning rows.
+// State is the folded view, an action is one mission, the reward is the
+// change in the judge's reading, and cost is the dollars the mission spent.
+// buildTrace is pure and deterministic: the same events give the same rows.
+// Doc: atris/features/campaign/traces.md.
+
+'use strict';
+
+const crypto = require('crypto');
+const { compareEvents, fold } = require('./campaign-core');
+const { judgeReading } = require('./campaign-reading');
+
+const SCHEMA = 'atris.campaign.trace';
+const VERSION = 1;
+
+const PRIVACY = {
+  redacted: 'Redacted: titles, objectives, verify commands, the judge command, judge summaries and output, and ask text are dropped. Campaign and mission ids are replaced by stable pseudonyms (Atris ids carry words from the title), and people show as "human". Numbers, members, engines, and outcomes stay.',
+  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.';
+
+function round(value, places = 6) {
+  const scale = 10 ** places;
+  return Math.round(value * scale) / scale;
+}
+
+function pseudonym(prefix, ...parts) {
+  return `${prefix}-${crypto.createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 12)}`;
+}
+
+// A judge run's reading: what the judge reported, else counts in its summary,
+// else 1 for a pass and 0 for a fail.
+function readingOf(run) {
+  if (!run) return { value: null, source: null };
+  if (typeof run.reading === 'number' && Number.isFinite(run.reading)) return { value: round(Math.min(1, Math.max(0, run.reading)), 4), source: 'graded' };
+  const parsed = run.summary ? judgeReading(String(run.summary)) : null;
+  if (parsed !== null) return { value: parsed, source: 'summary' };
+  return { value: run.passed ? 1 : 0, source: 'pass_fail' };
+}
+
+// The order the fold applies events in: duplicates dropped, sorted, the first
+// start moved to the front.
+function foldOrder(events) {
+  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.sort(compareEvents);
+  const start = ordered.find((e) => e.type === 'campaign_started');
+  return [start, ...ordered.filter((e) => e !== start)];
+}
+
+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,
+    judge_runs: view.judge_runs,
+    budget: view.budget,
+    missions,
+    open_asks: view.asks.length,
+  };
+}
+
+function judgeRunner(command) {
+  const first = String(command || '').trim().split(/\s+/)[0] || '';
+  return first.split('/').pop() || null;
+}
+
+// events: one campaign's events in any order. options.redact defaults to true.
+// Returns { header, rows } or { error }.
+function buildTrace(events, options = {}) {
+  const redact = options.redact !== false;
+  const final = fold(events);
+  if (final.error) return { error: final.error };
+  const sequence = foldOrder(events);
+  const campaignId = final.id;
+
+  const missions = new Map();
+  const judgeRuns = [];
+  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: [] });
+    return missions.get(id);
+  };
+
+  sequence.forEach((event, pos) => {
+    const d = event.data;
+    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;
+    }
+    if (event.type === 'ask_opened') {
+      if (!asks.has(d.ask_id)) asks.set(d.ask_id, { mission_id: d.mission_id || null, question: d.question, answer: null });
+      return;
+    }
+    if (event.type === 'ask_answered') {
+      const ask = asks.get(d.ask_id);
+      if (ask && ask.answer === null && String(event.actor).startsWith('human:')) ask.answer = d.answer;
+      return;
+    }
+    const missionId = typeof d.mission_id === 'string' && d.mission_id ? d.mission_id : null;
+    if (!missionId || event.type === 'budget_reserved' || event.type === 'budget_released') return;
+    const m = info(missionId);
+    if (m.firstPos === null) m.firstPos = pos;
+    if (typeof d.objective === 'string' && (m.objective === null || event.type === 'mission_proposed')) m.objective = d.objective;
+    if (typeof d.verify === 'string' && m.verify === null) m.verify = d.verify;
+    if (typeof d.member === 'string' && m.member === null) m.member = d.member;
+    // A planning step names the planner's engine, not the one that did the work.
+    if (typeof d.engine === 'string' && m.engine === null && d.kind !== 'plan') m.engine = d.engine;
+    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 === 'step') {
+      m.ticks += 1;
+      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) {
+      m.endPos = pos;
+      m.endData = d;
+      m.endAt = event.at;
+    }
+  });
+  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 lastRunBefore = (pos) => {
+    let found = null;
+    for (const run of judgeRuns) if (run.pos < pos) found = run;
+    return found;
+  };
+  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;
+    while (lo < hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      if (fold(sequence.slice(0, mid + 1)).state === 'done') hi = mid;
+      else lo = mid + 1;
+    }
+    finishPos = lo;
+  }
+
+  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);
+
+  // A batch: missions that ended between the same two judge runs.
+  const batches = new Map();
+  for (const m of ended) {
+    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);
+  }
+
+  const memberFor = (member) => (redact && typeof member === 'string' && member.startsWith('human:') ? 'human' : member);
+  const idFor = (missionId) => (redact ? pseudonym('m', campaignId, missionId) : missionId);
+  const outCampaign = redact ? pseudonym('cmp', campaignId) : campaignId;
+  const lastPos = sequence.length - 1;
+
+  const rows = ended.map((m, i) => {
+    const before = lastRunBefore(m.endPos);
+    const after = firstRunAfter(m.endPos);
+    const batch = batches.get(`${before ? before.pos : -1}:${after ? after.pos : 'open'}`);
+    const size = batch.missions.length;
+    const readBefore = readingOf(before);
+    const readAfter = readingOf(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';
+    else if (!before) creditNote = 'no judge run before this mission, so it has no reward';
+    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),
+      estimate_usd: m.estimate,
+    };
+    if (!redact) {
+      action.objective = m.objective;
+      action.verify = m.verify;
+    }
+    const row = {
+      kind: 'step',
+      campaign_id: outCampaign,
+      step: i + 1,
+      at: m.endAt,
+      batch: { index: batch.index, size },
+      state_before: compactState(view, lastRunBefore(startPos)),
+      action,
+      outcome: folded.outcome || m.endData.outcome,
+      cost_usd: folded.cost_usd === undefined || folded.cost_usd === null ? m.endData.cost_usd : folded.cost_usd,
+      ticks: m.ticks,
+      uncosted_ticks: uncosted,
+      human_asks: m.asks.length,
+      reading_before: readBefore.value,
+      reading_after: readAfter.value,
+      reading_source: readAfter.source,
+      reward: delta === null ? null : round(delta / size),
+      credit_note: creditNote,
+      done: finishPos !== null && finishPos <= (after ? after.pos : lastPos),
+      judge_passed: after ? after.passed : null,
+    };
+    if (!redact) {
+      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 }));
+    }
+    return row;
+  });
+
+  const lastRun = judgeRuns[judgeRuns.length - 1] || null;
+  const header = {
+    kind: 'header',
+    schema: SCHEMA,
+    version: VERSION,
+    campaign_id: outCampaign,
+    redacted: redact,
+    privacy: redact ? PRIVACY.redacted : PRIVACY.full,
+    judge: { runner: judgeRunner(final.judge), outside: true, runs: judgeRuns.length },
+    reward: REWARD,
+    rows: rows.length,
+    batches: batches.size,
+    pending_missions: final.missions.filter((m) => ['proposed', 'claimed', 'running'].includes(m.status)).length,
+    missions_not_run: final.missions.filter((m) => m.status === 'vetoed' || m.status === 'dropped').length,
+    campaign_asks: [...asks.values()].filter((ask) => !ask.mission_id).length,
+    events: sequence.length,
+    first_at: sequence[0].at,
+    last_at: sequence[lastPos].at,
+    final: {
+      state: final.state,
+      stop_reason: final.stop_reason,
+      confidence: final.answer.confidence,
+      reading: readingOf(lastRun).value,
+      standing: final.standing,
+      budget: final.budget,
+    },
+  };
+  if (!redact) {
+    header.title = final.title;
+    header.judge.command = final.judge;
+  }
+  return { header, rows };
+}
+
+function traceLines(trace) {
+  return [trace.header, ...trace.rows].map((row) => JSON.stringify(row)).join('\n') + '\n';
+}
+
+// atris campaign export <id> --trace [--out <file>] [--full]
+function exportTrace(args, ctx) {
+  const words = [];
+  for (let i = 1; i < args.length; i++) {
+    const arg = String(args[i]);
+    if (arg === '--out' || arg === '--as') { i++; continue; }
+    if (!arg.startsWith('--')) words.push(arg);
+  }
+  const { readFlag } = require('./arg-parser');
+  const id = words[0];
+  if (!id) return ctx.fail('name the campaign: atris campaign export <id> --trace [--out <file.jsonl>] [--full]');
+  const events = ctx.store.read(id);
+  if (!events.length) return ctx.fail(`no campaign ${id}. See them all with: atris campaign`, 1);
+  const full = args.includes('--full');
+  if (full && args.includes('--redact')) return ctx.fail('pick one: --redact (the default) or --full');
+  const trace = buildTrace(events, { redact: !full });
+  if (trace.error) return ctx.fail(`campaign ${id} cannot be read: ${trace.error}`, 1);
+  const text = traceLines(trace);
+  const out = readFlag(args, '--out', '');
+  if (!out) {
+    process.stdout.write(text);
+    return 0;
+  }
+  require('fs').writeFileSync(out, text);
+  const note = `wrote ${trace.rows.length} row${trace.rows.length === 1 ? '' : 's'} and a header to ${out}${full ? ' (full: includes objectives and judge output)' : ' (redacted)'}`;
+  ctx.out(note, { ok: true, action: 'export', path: out, rows: trace.rows.length, redacted: !full });
+  return 0;
+}
+
+module.exports = { SCHEMA, VERSION, buildTrace, exportTrace, readingOf, traceLines };

package/lib/conductor-artifacts.js

@@ -10,20 +10,34 @@ const CONDUCTOR_UNTRACKED_PATTERN =
 const CONDUCTOR_ROOT_OUTPUT_PATTERN = /^\.codex-last-message\.txt$/;
 const CONDUCTOR_RUN_OUTPUT_PATTERN = /^atris\/runs\/[^/]+\.(?:json|live\.log)$/;
 
+// Every atris call inside a work folder can write more of its own state under
+// .atris/ (engine health, usage, briefs). A list of names always lagged: on
+// 2026-10-15 .atris/state/engines.json and usage.jsonl made every dispatch
+// guard fail on a fresh repo. A NEW file under .atris/ is always the tool's
+// own, so untracked checks skip the whole folder. Tracked .atris/ files keep
+// the exact list, since a repo may commit some of them on purpose.
+const ATRIS_OWN_DIR_PATTERN = /^\.atris\//;
+
 function isConductorArtifact(file) {
   const value = String(file || '');
   return CONDUCTOR_UNTRACKED_PATTERN.test(value) || CONDUCTOR_ROOT_OUTPUT_PATTERN.test(value)
     || CONDUCTOR_RUN_OUTPUT_PATTERN.test(value);
 }
 
+// For files git does not track yet.
+function isConductorUntracked(file) {
+  return isConductorArtifact(file) || ATRIS_OWN_DIR_PATTERN.test(String(file || ''));
+}
+
 // Accepts a `git status --porcelain` line ("?? .atris/fleet-prompt-BCK-1.md").
 function isConductorStatusLine(line) {
   const text = String(line || '');
   if (!text.startsWith('?? ')) return false;
-  return isConductorArtifact(text.slice(3));
+  return isConductorUntracked(text.slice(3));
 }
 
 module.exports = {
   isConductorArtifact,
   isConductorStatusLine,
+  isConductorUntracked,
 };

package/lib/daily-log.js

@@ -46,7 +46,17 @@ function memberSlug(root, member) {
   return slug;
 }
 
-function appendMemberDailyEntry(root, member, title, fields) {
+// Member logs are gitignored, so one written inside a work folder dies when
+// that folder is reaped. A linked worktree writes to its main checkout instead
+// when the main checkout knows the member.
+function memberLogRoot(root, member) {
+  const { mainCheckoutRoot } = require('./engine-registry');
+  const main = mainCheckoutRoot(root);
+  return main && memberSlug(main, member) ? main : root;
+}
+
+function appendMemberDailyEntry(workspaceRoot, member, title, fields) {
+  const root = memberLogRoot(workspaceRoot, member);
   const slug = memberSlug(root, member);
   if (!slug || !fs.existsSync(path.join(root, 'atris'))) return null;
   const logPath = path.join(root, 'atris', 'team', slug, 'logs', todayLogName());