atris 3.71.1 → 3.71.3

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-trace.js

@@ -7,7 +7,7 @@
 'use strict';
 
 const crypto = require('crypto');
-const { compareEvents, fold } = require('./campaign-core');
+const { compareEvents, fold, foldWithPrefixes } = 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;
@@ -84,14 +84,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 +123,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,12 +137,13 @@ 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
+    ? foldWithPrefixes(sequence, ended.map((m) => Math.max(1, m.firstPos === null ? m.endPos : m.firstPos)),
+      (view) => compactState(view, null)).prefixes
+    : new Map();
   const lastRunBefore = (pos) => {
     let found = null;
     for (const run of judgeRuns) if (run.pos < pos) found = run;
@@ -156,7 +165,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 +173,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 +189,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 && judgeChanges.some(pos => pos > before.pos && 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 +226,9 @@ function buildTrace(events, options = {}) {
       step: i + 1,
       at: m.endAt,
       batch: { index: batch.index, size },
-      state_before: compactState(view, lastRunBefore(startPos)),
+      state_before: { ...prefixStates.get(Math.max(1, startPos)), reading: readingOf(lastRunBefore(startPos)).value },
       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 +236,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/mission-code-provenance.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const fs = require('fs');
+const { devNull } = require('os');
+const { spawnSync } = require('child_process');
+
+const BASELINE_SCHEMA = 'atris.mission_code_baseline.v1';
+const PROVENANCE_SCHEMA = 'atris.mission_code_provenance.v1';
+const BOOKKEEPING = ['.atris/', 'atris/runs/', 'atris/status/'];
+
+function fail(reason) {
+  throw new Error(reason);
+}
+
+function git(root, args, reason = 'git_command_failed') {
+  // Disabling replacements alone still permits info/grafts and inherited graft
+  // files to rewrite ancestry. Evidence needs the actual commit relationships.
+  const env = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_GRAFT_FILE: devNull };
+  // Evidence belongs to this on-disk repository, even when the caller was
+  // launched by a Git hook with another index or repository in its environment.
+  for (const key of ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE', 'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_NAMESPACE', 'GIT_SHALLOW_FILE']) delete env[key];
+  const result = spawnSync('git', ['-c', 'core.fsmonitor=false', ...args], {
+    cwd: root, env, timeout: 15000, maxBuffer: Infinity,
+  });
+  if (result.error || result.status !== 0 || !Buffer.isBuffer(result.stdout)) fail(reason);
+  const text = result.stdout.toString('utf8');
+  // A lossy filename decode cannot stand in for a complete path list.
+  if (!Buffer.from(text, 'utf8').equals(result.stdout)) fail('git_output_unreadable');
+  return text;
+}
+
+function repositoryRoot(root) {
+  const physical = fs.realpathSync(root);
+  const top = git(physical, ['rev-parse', '--show-toplevel'], 'not_git_repository').replace(/\n$/, '');
+  if (fs.realpathSync(top) !== physical) fail('root_not_git_top_level');
+  return physical;
+}
+
+function nulEntries(text) {
+  if (!text) return [];
+  if (!text.endsWith('\0')) fail('git_output_incomplete');
+  return text.slice(0, -1).split('\0');
+}
+
+function knownCommit(root, commit) {
+  if (typeof commit !== 'string' || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(commit)) fail('commit_unavailable');
+  if (git(root, ['cat-file', '-t', commit], 'commit_unavailable').trim() !== 'commit') fail('commit_unavailable');
+  return commit;
+}
+
+function cleanHead(root) {
+  const head = knownCommit(root, git(root, ['rev-parse', '--verify', 'HEAD'], 'head_unavailable').trim());
+  // Disabling rename detection exposes both paths, including a product file
+  // moved into a bookkeeping directory. Every untracked file is inspected.
+  const entries = nulEntries(git(root, [
+    'status', '--porcelain=v1', '-z', '--untracked-files=all', '--no-renames', '--ignore-submodules=none',
+  ], 'git_status_unavailable'));
+  for (const entry of entries) {
+    if (entry.length < 4 || entry[2] !== ' ') fail('git_status_unreadable');
+    if (!BOOKKEEPING.some((prefix) => entry.slice(3).startsWith(prefix))) fail('product_dirty');
+  }
+  if (git(root, ['rev-parse', '--verify', 'HEAD'], 'head_unavailable').trim() !== head) fail('head_changed_during_capture');
+  return head;
+}
+
+function committedFiles(root, base, head) {
+  knownCommit(root, base);
+  knownCommit(root, head);
+  git(root, ['merge-base', '--is-ancestor', base, head], 'base_not_ancestor');
+  // No sample, path filter, or rename folding: deleted and renamed source
+  // paths matter as much as additions, including committed bookkeeping.
+  return nulEntries(git(root, [
+    'diff', '--name-only', '--no-renames', '--no-ext-diff', '--no-textconv', '-z', base, head, '--',
+  ], 'git_diff_unavailable'));
+}
+
+function unavailable(schema, error) {
+  return { schema, status: 'unavailable', reason: error?.message || 'git_evidence_unavailable' };
+}
+
+function captureCodeBaseline(root) {
+  try {
+    const repo_root = repositoryRoot(root);
+    return { schema: BASELINE_SCHEMA, status: 'complete', repo_root, base_commit: cleanHead(repo_root) };
+  } catch (error) {
+    return unavailable(BASELINE_SCHEMA, error);
+  }
+}
+
+function collectCodeProvenance(root, baseline) {
+  try {
+    if (baseline?.schema !== BASELINE_SCHEMA || baseline.status !== 'complete') fail('baseline_unavailable');
+    const repo_root = repositoryRoot(root);
+    if (baseline.repo_root !== repo_root) fail('baseline_repository_mismatch');
+    const head_commit = cleanHead(repo_root);
+    const base_commit = baseline.base_commit;
+    const files = committedFiles(repo_root, base_commit, head_commit);
+    return { schema: PROVENANCE_SCHEMA, status: 'complete', repo_root, base_commit, head_commit, files };
+  } catch (error) {
+    return unavailable(PROVENANCE_SCHEMA, error);
+  }
+}
+
+function verifyCodeProvenance(root, provenance) {
+  try {
+    if (provenance?.schema !== PROVENANCE_SCHEMA || provenance.status !== 'complete' || !Array.isArray(provenance.files)) fail('provenance_unavailable');
+    const repo_root = repositoryRoot(root);
+    if (provenance.repo_root !== repo_root) fail('provenance_repository_mismatch');
+    // Historical evidence stays valid when the current checkout moves on.
+    const actual = committedFiles(repo_root, provenance.base_commit, provenance.head_commit);
+    if (actual.length !== provenance.files.length || actual.some((file, index) => file !== provenance.files[index])) fail('provenance_files_mismatch');
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, reason: error?.message || 'git_evidence_unavailable' };
+  }
+}
+
+module.exports = { captureCodeBaseline, collectCodeProvenance, verifyCodeProvenance };

package/lib/pulse.js

@@ -603,6 +603,7 @@ function buildTickScript(opts = {}) {
     pathDirs = [],
     launchLabel = '',
     launchPlistPath = '',
+    tickFlags = [],
   } = opts;
   if (!root) throw new Error('buildTickScript: root is required');
   if (!stateHome) throw new Error('buildTickScript: stateHome is required');
@@ -690,7 +691,7 @@ ${runnerBinExport}
 ${runnerCommandTemplateExport}
 export ATRIS_SKIP_UPDATE_CHECK=1
 
-"$ATRIS" pulse tick --json${safeVerify == null ? '' : ` --verify '${safeVerify}'`} >> "$log" 2>&1
+"$ATRIS" pulse tick --json${tickFlags.filter((f) => /^--[a-z-]+$/.test(f)).map((f) => ` ${f}`).join('')}${safeVerify == null ? '' : ` --verify '${safeVerify}'`} >> "$log" 2>&1
 tick_status=$?
 
 # runDaily no-ops via last_run_date after the first daily run.

package/lib/rsi-record.js

@@ -320,6 +320,93 @@ function finishAttempt(root, attempt, outcome = {}, { log = () => {} } = {}) {
   }
 }
 
+// Observed history did not run under today's policy. Use the schema directly:
+// open/finish would invent current action and completion times for old work.
+const OBSERVED_APPEND_PY = `import json, sys
+from dataclasses import asdict
+from datetime import datetime
+sys.path.insert(0, sys.argv[1])
+from backend.scripts.rsi.schema import Action, Context, Node, Outcome, append_node, tree_split
+from backend.scripts.rsi.record import get_node
+data = json.loads(sys.argv[2])
+def instant(value): return datetime.fromisoformat(value.replace('Z', '+00:00'))
+if data.get('nodeId'):
+    node = get_node(data['nodeId'])
+    if (node is None or node.lane != data['lane'] or
+        node.context.ground != data['ground'] or node.action.ground != data['ground'] or
+        node.action.engine != data['engine'] or node.action.policy_id != 'p-0000' or
+        node.context.base_commit != data['baseCommit'] or node.outcome.status == 'running' or
+        instant(node.opened_at) != instant(data['openedAt']) or
+        instant(node.created_at) != instant(data['finishedAt'])):
+        raise ValueError('observed attempt identity, policy, or provenance does not match')
+    outcome = asdict(node.outcome)
+    outcome.update(data['outcome'])
+    node.outcome = Outcome(**outcome)
+    node.recorded_at = None
+else:
+    node = Node(
+        tree_id=data['tree'], lane=data['lane'],
+        context=Context(base_commit=data['baseCommit'], ground=data['ground']),
+        action=Action(policy_id='p-0000', kind='open', ground=data['ground'], engine=data['engine'], model=None, cap_s=0),
+        outcome=Outcome(**data['outcome']), split=tree_split(data['tree']),
+        created_at=data['finishedAt'], opened_at=data['openedAt'])
+append_node(node)
+print(node.id)
+`;
+
+function observedTime(value) {
+  if (typeof value !== 'string') return NaN;
+  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/);
+  if (!match) return NaN;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (month < 1 || month > 12 || day < 1 || day > days[month - 1]) return NaN;
+  return Date.parse(value);
+}
+
+/** Append measured completed work, preserving its historical provenance.
+ * Missing metadata or an unavailable backend schema defers recording. This
+ * never chooses a policy and never changes the active-attempt environment.
+ */
+function recordObservedAttempt(root, options = {}, { log = () => {} } = {}) {
+  const report = (message) => { try { log(message); } catch {} };
+  try {
+    const { lane = 'campaign', ground, engine, baseCommit, openedAt, finishedAt, outcome, nodeId } = options;
+    const engines = new Set(['codex', 'devin', 'cursor', 'agy', 'claude']);
+    const opened = observedTime(openedAt);
+    const finished = observedTime(finishedAt);
+    if (!root || !recorderPath(root) || typeof lane !== 'string' || !lane.trim() ||
+        typeof ground !== 'string' || !ground.trim() || !engines.has(engine) ||
+        typeof baseCommit !== 'string' || !/^[a-fA-F0-9]{7,64}$/.test(baseCommit) ||
+        !Number.isFinite(opened) || !Number.isFinite(finished) || opened > finished || finished > Date.now() ||
+        !outcome || typeof outcome !== 'object' || Array.isArray(outcome) ||
+        !['shipped', 'failed', 'nothing', 'waiting'].includes(outcome.status) ||
+        !['pass', 'fail', 'skipped'].includes(outcome.verify) ||
+        !Array.isArray(outcome.files) || !outcome.files.length ||
+        !Array.from(outcome.files).every((file) => typeof file === 'string' && file.trim()) ||
+        (nodeId !== undefined && (typeof nodeId !== 'string' || !nodeId.trim()))) return null;
+    const tree = nodeId ? null : startTree(root, lane);
+    if (!nodeId && !tree) {
+      report('rsi: observed attempt skipped (could not select a tree)');
+      return null;
+    }
+    const result = spawnSync(pythonBin(root), ['-c', OBSERVED_APPEND_PY, root,
+      JSON.stringify({ lane, ground, engine, baseCommit, openedAt, finishedAt, outcome, nodeId, tree })], {
+      cwd: root, encoding: 'utf8', timeout: SPAWN_TIMEOUT_MS, env: process.env,
+    });
+    const id = result.status === 0 ? String(result.stdout || '').trim().split('\n').pop() : '';
+    if (id) return id;
+    report(`rsi: observed attempt skipped${result.stderr ? ` (${String(result.stderr).trim().split('\n').pop()})` : ''}`);
+    return null;
+  } catch (error) {
+    report(`rsi: observed attempt skipped (${error && error.message ? error.message : error})`);
+    return null;
+  }
+}
+
 module.exports = {
   IMPROVE_LANE,
   GUARD_ENV,
@@ -332,4 +419,5 @@ module.exports = {
   engineFromModel,
   beginAttempt,
   finishAttempt,
+  recordObservedAttempt,
 };

package/lib/task-receipt.js

@@ -43,6 +43,14 @@ function slugifyTaskId(taskId) {
     .slice(0, 40) || 'task';
 }
 
+function verifyTimeoutMs() {
+  // Match the audit and certification budget, including its one-hour ceiling.
+  const raw = Number(process.env.ATRIS_VERIFY_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0
+    ? Math.min(Math.ceil(raw), 60 * 60 * 1000)
+    : 10 * 60 * 1000;
+}
+
 // Runs `command` for `taskId`, writes atris/runs/<date>-task-<id>-<time>.json,
 // and returns { ok, passed, receiptPath, exit, signal, output }. `ok` mirrors
 // `passed`, kept as a separate field so callers reading either name work.
@@ -56,16 +64,24 @@ function writeTaskReceipt({ taskId, command, root = process.cwd(), runner } = {}
   // support. Put the node running atris first, after the profile has loaded.
   const nodeDir = path.dirname(process.execPath).replace(/'/g, `'\\''`);
   const script = `export PATH='${nodeDir}':"$PATH"\n${cmd}`;
+  const timeoutMs = verifyTimeoutMs();
   const result = run('bash', ['-lc', script], {
     cwd: root,
     encoding: 'utf8',
-    timeout: 120000,
+    timeout: timeoutMs,
   });
-  if (result.error) {
-    return { ok: false, passed: false, reason: 'verifier_spawn_failed', error: result.error.message, cmd };
-  }
-  const output = tailText(`${result.stdout || ''}${result.stderr || ''}`);
-  const passed = result.status === 0;
+  const failure = result.error ? {
+    error: result.error.message,
+    error_code: result.error.code || null,
+    timeout_ms: timeoutMs,
+  } : {};
+  const diagnostic = result.error
+    ? (result.error.code === 'ETIMEDOUT'
+      ? `\nverification timed out after ${timeoutMs / 1000} seconds.`
+      : '\nverification did not complete.')
+    : '';
+  const output = tailText(`${result.stdout || ''}${result.stderr || ''}${diagnostic}`);
+  const passed = !result.error && result.status === 0;
   const dir = runsDir(root);
   fs.mkdirSync(dir, { recursive: true });
   const now = new Date();
@@ -84,6 +100,7 @@ function writeTaskReceipt({ taskId, command, root = process.cwd(), runner } = {}
       exit: result.status,
       signal: result.signal || null,
       output,
+      ...failure,
     },
   };
   fs.writeFileSync(receiptFile, JSON.stringify(receipt, null, 2) + '\n', 'utf8');
@@ -96,6 +113,7 @@ function writeTaskReceipt({ taskId, command, root = process.cwd(), runner } = {}
     signal: result.signal || null,
     output,
     cmd,
+    ...(result.error ? { reason: 'verifier_spawn_failed', ...failure } : {}),
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.71.1",
+  "version": "3.71.3",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {