atris 3.35.0 → 3.37.0

package/lib/receipt-block.js

@@ -0,0 +1,168 @@
+'use strict';
+
+const { historicalLandingText } = require('./autoland');
+
+function compactLine(value) {
+  return String(value == null ? '' : value)
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function asciiLine(value) {
+  return compactLine(value)
+    .replace(/[\u2013\u2014]/g, '-')
+    .replace(/[^\S\r\n]+/g, ' ');
+}
+
+function lowerLine(value) {
+  return asciiLine(value).toLowerCase();
+}
+
+function trimPunctuation(value) {
+  return asciiLine(value).replace(/[.!?:;,]+$/g, '').trim();
+}
+
+function truncateLine(value, max = 180) {
+  const text = asciiLine(value);
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 3)).trimEnd()}...`;
+}
+
+function landing(receipt) {
+  const value = receipt && receipt.result && receipt.result.landing;
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function result(receipt) {
+  const value = receipt && receipt.result;
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function verifierResult(receipt) {
+  const res = result(receipt);
+  const value = res.verifier_result || res.tick?.verifier_result || null;
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+function changedText(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  const text = land.changed
+    || land.happened
+    || res.tick?.summary
+    || res.tick?.claude?.summary
+    || res.tick?.atris2?.receipt_text
+    || res.summary
+    || receipt?.objective
+    || 'mission receipt recorded';
+  return lowerLine(text);
+}
+
+function statusText(receipt) {
+  const land = landing(receipt);
+  const res = result(receipt);
+  const status = land.status || res.status || res.tick?.status || (res.passed === true ? 'proof_ready' : '');
+  return lowerLine(status || 'recorded');
+}
+
+function scaleText(receipt) {
+  const res = result(receipt);
+  const worktree = res.worktree || res.tick?.worktree || {};
+  const changedCount = Number(
+    worktree.new_since_baseline_count
+    || worktree.new_dirty_count
+    || worktree.dirty_count
+    || 0,
+  );
+  if (Number.isFinite(changedCount) && changedCount > 0) {
+    return changedCount === 1 ? '1 changed file' : `${changedCount} changed files`;
+  }
+
+  const tickCount = Number(res.tick_count || 0);
+  if (Number.isFinite(tickCount) && tickCount > 0) {
+    return tickCount === 1 ? '1 tick' : `${tickCount} ticks`;
+  }
+
+  const ranTicks = Number(res.ran_ticks || 0);
+  if (Number.isFinite(ranTicks) && ranTicks > 0) {
+    return ranTicks === 1 ? '1 ran tick' : `${ranTicks} ran ticks`;
+  }
+
+  if (res.tick || res.kind === 'mission_tick' || res.kind === 'mission_run_tick') return '1 tick';
+  return '1 receipt';
+}
+
+function directProofText(value) {
+  const text = lowerLine(value);
+  const ran = trimPunctuation(text).match(/^i ran (.+)$/);
+  return ran ? `${ran[1]} passed` : text;
+}
+
+function proofText(receipt) {
+  const land = landing(receipt);
+  const verifier = verifierResult(receipt);
+  if (land.checked) return directProofText(land.checked);
+  if (land.tested) return directProofText(land.tested);
+  if (verifier) {
+    const command = lowerLine(verifier.command || receipt?.verifier || 'configured verifier');
+    return `${command} ${verifier.passed ? 'passed' : 'failed'}`;
+  }
+  if (result(receipt).passed === true) return 'receipt says verifier passed';
+  if (receipt?.at) return `receipt saved at ${lowerLine(receipt.at)}`;
+  return 'receipt is present';
+}
+
+function nextText(receipt) {
+  const text = landing(receipt).next || result(receipt).next || '';
+  return lowerLine(text);
+}
+
+function renderEmailLine(receipt) {
+  const what = historicalLandingText(trimPunctuation(changedText(receipt)), 180);
+  const scale = scaleText(receipt);
+  const proof = historicalLandingText(trimPunctuation(proofText(receipt)), 90);
+  return `${what}; ${scale}; we know because ${proof}.`;
+}
+
+function renderMorningCardRow(receipt) {
+  return `- mission: ${renderEmailLine(receipt).replace(/\.$/, '')}`;
+}
+
+function renderPageSection(receipt) {
+  const next = nextText(receipt);
+  const lines = [
+    '## mission receipt',
+    '',
+    `- what: ${truncateLine(trimPunctuation(changedText(receipt)), 160)}`,
+    `- how big: ${scaleText(receipt)}`,
+    `- how we know: ${truncateLine(trimPunctuation(proofText(receipt)), 160)}`,
+    `- status: ${statusText(receipt)}`,
+  ];
+  if (receipt?.mission_id) lines.push(`- mission: ${lowerLine(receipt.mission_id)}`);
+  if (next) lines.push(`- next: ${truncateLine(trimPunctuation(next), 160)}`);
+  return lines.join('\n');
+}
+
+function renderCard(receipt) {
+  const status = statusText(receipt);
+  const what = truncateLine(trimPunctuation(changedText(receipt)), 64);
+  const scale = scaleText(receipt);
+  const proof = truncateLine(trimPunctuation(proofText(receipt)), 88);
+  return {
+    kind: 'statement',
+    headline: what,
+    text: what,
+    kicker: `${status} mission receipt`,
+    sub: `${scale}; ${proof}`,
+    brand: 'atris',
+    size: 'og',
+    theme: 'atris',
+  };
+}
+
+module.exports = {
+  renderCard,
+  renderPageSection,
+  renderEmailLine,
+  renderMorningCardRow,
+};

package/lib/receipt-evidence.js

@@ -16,11 +16,65 @@ const MAX_RECEIPTS = 5;
 function receiptVerifierPassed(receipt) {
   const result = receipt?.result;
   if (!result || typeof result !== 'object') return null;
-  if (result.passed === true || result.verifier_result?.passed === true || result.tick?.verifier_passed === true) return true;
-  if (result.passed === false || result.verifier_result?.passed === false || result.tick?.verifier_passed === false) return false;
+  const oneLapReview = receipt?.schema === 'atris.dispatch_receipt.v1'
+    && receipt?.review_only === true
+    && receipt?.context?.source === 'one_lap';
+  if (oneLapReview) {
+    const validator = result.validator_result;
+    const validatorEngine = String(validator?.engine || '').trim();
+    const executorEngine = String(validator?.executor_engine || '').trim();
+    return result.passed === true
+      && result.master_boundary_enforced === true
+      && result.master_unchanged === true
+      && validator?.passed === true
+      && validator?.independent === true
+      && validator?.worktree_unchanged === true
+      && Boolean(validatorEngine)
+      && Boolean(executorEngine)
+      && validatorEngine !== executorEngine;
+  }
+  // The receipt's aggregate result is authoritative. A nested verifier can
+  // explain one green check inside a failed flight, but it cannot turn that
+  // failed flight into passing evidence.
+  if (typeof result.passed === 'boolean') return result.passed;
+  const nested = [result.verifier_result?.passed, result.tick?.verifier_passed];
+  if (nested.includes(false)) return false;
+  if (nested.includes(true)) return true;
   return null;
 }
 
+// A forced completion means the mission's own gate said no and an operator
+// overrode it. The receipt can still show a passing verifier, so the forced
+// flag lives in mission state (`completion_gate.forced`); read it back here
+// so the review queue shows forced work as forced, not as passing evidence.
+function loadForcedMissionIds(root) {
+  const forced = new Map();
+  let raw;
+  try {
+    raw = fs.readFileSync(path.resolve(root, '.atris/state/missions.jsonl'), 'utf8');
+  } catch {
+    return forced;
+  }
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let parsed = null;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    const mission = parsed?.mission && typeof parsed.mission === 'object' ? parsed.mission : parsed;
+    const id = mission?.id || parsed?.mission_id;
+    if (!id) continue;
+    // Last record for a mission wins: an honest re-completion clears the flag.
+    forced.set(id, mission?.completion_gate?.forced === true);
+  }
+  return forced;
+}
+
+function receiptForced(receipt, forcedMissionIds) {
+  if (receipt?.completion_gate?.forced === true) return true;
+  if (receipt?.mission?.completion_gate?.forced === true) return true;
+  const missionId = receipt?.mission_id || receipt?.mission?.id;
+  return Boolean(missionId && forcedMissionIds.get(missionId) === true);
+}
+
 function extractReceiptEvidence(proofText, root = process.cwd()) {
   const text = String(proofText || '');
   const found = [];
@@ -37,6 +91,7 @@ function extractReceiptEvidence(proofText, root = process.cwd()) {
 
   const receipts = [];
   const missing = [];
+  let forcedMissionIds = null;
   for (const rel of found) {
     let raw;
     try {
@@ -51,13 +106,19 @@ function extractReceiptEvidence(proofText, root = process.cwd()) {
     const passed = receiptVerifierPassed(parsed);
     if (passed !== null) entry.verifier_passed = passed;
     if (parsed?.mission_id) entry.mission_id = parsed.mission_id;
+    if (forcedMissionIds === null) forcedMissionIds = loadForcedMissionIds(root);
+    if (receiptForced(parsed, forcedMissionIds)) entry.forced = true;
     receipts.push(entry);
   }
+  const anyForced = receipts.some((entry) => entry.forced === true);
   return {
     receipts,
     missing,
-    // True only when every named receipt exists and none shows a failing verifier.
-    all_passing: receipts.length > 0 && !missing.length && receipts.every((entry) => entry.verifier_passed !== false),
+    any_forced: anyForced,
+    // Unknown verifier state is not proof, and a forced completion is not
+    // passing evidence: every named receipt must explicitly pass, unforced.
+    all_passing: receipts.length > 0 && !missing.length && !anyForced
+      && receipts.every((entry) => entry.verifier_passed === true),
   };
 }
 

package/lib/router-brain.js

@@ -0,0 +1,352 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_MIN_RECEIPTS = 3;
+const DEFAULT_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+const DURATION_SCALE_MS = 60 * 1000;
+
+function objectValue(value) {
+  return value && typeof value === 'object' ? value : null;
+}
+
+function recordContainers(record) {
+  const row = objectValue(record);
+  if (!row) return [];
+  return [
+    row,
+    objectValue(row.payload),
+    objectValue(row.result),
+    objectValue(row.tick),
+    objectValue(row.result?.tick),
+    objectValue(row.payload?.tick),
+    objectValue(row.verifier_result),
+    objectValue(row.result?.verifier_result),
+    objectValue(row.payload?.verifier_result),
+    objectValue(row.mission),
+    objectValue(row.context),
+  ].filter(Boolean);
+}
+
+function firstField(containers, names, accept = (value) => value != null) {
+  for (const container of containers) {
+    for (const name of names) {
+      const value = container[name];
+      if (accept(value)) return value;
+    }
+  }
+  return null;
+}
+
+function normalizedLabel(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function finiteNonnegative(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
+function recordDuration(containers) {
+  const direct = firstField(
+    containers,
+    ['duration_ms', 'durationMs', 'elapsed_ms', 'elapsedMs'],
+    (value) => finiteNonnegative(value) !== null,
+  );
+  if (direct !== null) return finiteNonnegative(direct);
+  for (const container of containers) {
+    const started = Date.parse(String(container.started_at || container.startedAt || ''));
+    const finished = Date.parse(String(container.finished_at || container.finishedAt || ''));
+    if (Number.isFinite(started) && Number.isFinite(finished) && finished >= started) {
+      return finished - started;
+    }
+  }
+  return null;
+}
+
+function recordTimestamp(containers, fallbackMs) {
+  const raw = firstField(containers, [
+    'at',
+    'ts',
+    'finished_at',
+    'finishedAt',
+    'created_at',
+    'createdAt',
+    'updated_at',
+    'updatedAt',
+    'started_at',
+    'startedAt',
+  ]);
+  const parsed = Date.parse(String(raw || ''));
+  if (Number.isFinite(parsed)) return parsed;
+  return Number.isFinite(fallbackMs) ? fallbackMs : Date.now();
+}
+
+function observationFromRecord(record, source, fallbackMs) {
+  const containers = recordContainers(record);
+  const engine = normalizedLabel(firstField(containers, [
+    'engine_id',
+    'engine',
+    'selected_engine',
+    'executor_engine',
+    'runner',
+  ]));
+  const taskType = normalizedLabel(firstField(containers, [
+    'task_type',
+    'taskType',
+    'job_type',
+    'jobType',
+    'role',
+    'kind',
+  ]));
+  const passed = firstField(
+    containers,
+    ['verified_passed', 'verifier_passed', 'passed', 'verified'],
+    (value) => typeof value === 'boolean',
+  );
+  if (!engine || !taskType || typeof passed !== 'boolean') return null;
+  return {
+    engine,
+    task_type: taskType,
+    verified_passed: passed,
+    duration_ms: recordDuration(containers),
+    at_ms: recordTimestamp(containers, fallbackMs),
+    source,
+  };
+}
+
+function readTaskReceiptObservations(root) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let entries;
+  try {
+    entries = fs.readdirSync(runsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.json') || !entry.name.includes('task-')) continue;
+    const file = path.join(runsDir, entry.name);
+    try {
+      const stat = fs.statSync(file);
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const observation = observationFromRecord(parsed, path.relative(root, file), stat.mtimeMs);
+      if (observation) observations.push(observation);
+    } catch {}
+  }
+  return observations;
+}
+
+function readMissionEventObservations(root) {
+  const file = path.join(root, '.atris', 'state', 'mission_events.jsonl');
+  let raw;
+  let fallbackMs = Date.now();
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+    fallbackMs = fs.statSync(file).mtimeMs;
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const observation = observationFromRecord(JSON.parse(line), path.relative(root, file), fallbackMs);
+      if (observation) observations.push(observation);
+    } catch {}
+  }
+  return observations;
+}
+
+function readDispatchReceiptObservations(root) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let entries;
+  try {
+    entries = fs.readdirSync(runsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith('dispatch-') || !entry.name.endsWith('.json')) continue;
+    const file = path.join(runsDir, entry.name);
+    try {
+      const stat = fs.statSync(file);
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const results = Array.isArray(parsed?.results) ? parsed.results : [];
+      for (const [index, row] of results.entries()) {
+        if (typeof row?.verified_passed !== 'boolean') continue;
+        const source = `${path.relative(root, file)}#results[${index}]`;
+        const observation = observationFromRecord(row, source, stat.mtimeMs);
+        if (observation) observations.push(observation);
+      }
+    } catch {}
+  }
+  return observations;
+}
+
+function loadRouterHistory(root = process.cwd()) {
+  return [
+    ...readTaskReceiptObservations(root),
+    ...readMissionEventObservations(root),
+    ...readDispatchReceiptObservations(root),
+  ];
+}
+
+function median(values) {
+  const sorted = values
+    .map(finiteNonnegative)
+    .filter((value) => value !== null)
+    .sort((left, right) => left - right);
+  if (!sorted.length) return null;
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2
+    ? sorted[middle]
+    : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+
+function historyKey(engine, taskType) {
+  return `${normalizedLabel(engine)}\u0000${normalizedLabel(taskType)}`;
+}
+
+function computeEngineTaskStats(observations, options = {}) {
+  const nowValue = options.now instanceof Date ? options.now.getTime() : Number(options.now ?? Date.now());
+  const nowMs = Number.isFinite(nowValue) ? nowValue : Date.now();
+  const halfLifeValue = Number(options.halfLifeMs ?? DEFAULT_HALF_LIFE_MS);
+  const halfLifeMs = Number.isFinite(halfLifeValue) && halfLifeValue > 0
+    ? halfLifeValue
+    : DEFAULT_HALF_LIFE_MS;
+  const groups = new Map();
+  for (const row of Array.isArray(observations) ? observations : []) {
+    const engine = normalizedLabel(row?.engine);
+    const taskType = normalizedLabel(row?.task_type || row?.taskType);
+    if (!engine || !taskType || typeof row?.verified_passed !== 'boolean') continue;
+    const key = historyKey(engine, taskType);
+    const group = groups.get(key) || { engine, task_type: taskType, receipts: [] };
+    group.receipts.push(row);
+    groups.set(key, group);
+  }
+
+  return [...groups.values()].map((group) => {
+    let weightedPasses = 0;
+    let totalWeight = 0;
+    let verifiedPasses = 0;
+    for (const receipt of group.receipts) {
+      const atMs = Number(receipt.at_ms);
+      const ageMs = Number.isFinite(atMs) ? Math.max(0, nowMs - atMs) : halfLifeMs;
+      const weight = Math.pow(0.5, ageMs / halfLifeMs);
+      totalWeight += weight;
+      if (receipt.verified_passed) {
+        verifiedPasses += 1;
+        weightedPasses += weight;
+      }
+    }
+    const receiptCount = group.receipts.length;
+    const passRate = verifiedPasses / receiptCount;
+    const weightedPassRate = totalWeight > 0 ? weightedPasses / totalWeight : passRate;
+    const medianDurationMs = median(group.receipts.map((receipt) => receipt.duration_ms));
+    const durationScore = medianDurationMs === null
+      ? 0
+      : 1 / (1 + (medianDurationMs / DURATION_SCALE_MS));
+    return {
+      engine: group.engine,
+      task_type: group.task_type,
+      receipt_count: receiptCount,
+      verified_passes: verifiedPasses,
+      verified_failures: receiptCount - verifiedPasses,
+      verified_pass_rate: passRate,
+      median_duration_ms: medianDurationMs,
+      recency_weighted_score: (weightedPassRate * 0.85) + (durationScore * 0.15),
+    };
+  }).sort((left, right) => left.engine.localeCompare(right.engine)
+    || left.task_type.localeCompare(right.task_type));
+}
+
+function candidateId(candidate) {
+  return normalizedLabel(typeof candidate === 'string' ? candidate : candidate?.id || candidate?.name);
+}
+
+function fallbackOrder(candidate, index) {
+  const value = Number(candidate && typeof candidate === 'object' ? candidate.fallback_order : NaN);
+  return Number.isFinite(value) ? value : index;
+}
+
+function legacyRank(candidates) {
+  return candidates
+    .map((candidate, index) => ({ candidate, index }))
+    .sort((left, right) => fallbackOrder(left.candidate, left.index) - fallbackOrder(right.candidate, right.index)
+      || candidateId(left.candidate).localeCompare(candidateId(right.candidate)))
+    .map((entry) => entry.candidate);
+}
+
+function rankEnginesDetailed(candidates, options = {}) {
+  const input = Array.isArray(candidates) ? candidates : [];
+  const legacy = legacyRank(input);
+  const taskType = normalizedLabel(options.taskType || options.task_type);
+  const minValue = Number(options.minReceipts ?? DEFAULT_MIN_RECEIPTS);
+  const minReceipts = Number.isInteger(minValue) && minValue > 0 ? minValue : DEFAULT_MIN_RECEIPTS;
+  const observations = Array.isArray(options.observations)
+    ? options.observations
+    : loadRouterHistory(options.root || process.cwd());
+  const stats = computeEngineTaskStats(observations, options);
+  const statsByEngine = new Map(stats
+    .filter((row) => row.task_type === taskType)
+    .map((row) => [row.engine, row]));
+  const thinEngines = legacy
+    .map(candidateId)
+    .filter((engine) => !statsByEngine.has(engine) || statsByEngine.get(engine).receipt_count < minReceipts);
+
+  if (!taskType || thinEngines.length) {
+    return {
+      candidates: legacy,
+      stats,
+      task_type: taskType,
+      used_track_record: false,
+      thin_engines: thinEngines,
+    };
+  }
+
+  const ranked = legacy
+    .map((candidate, index) => ({ candidate, index, stats: statsByEngine.get(candidateId(candidate)) }))
+    .sort((left, right) => right.stats.recency_weighted_score - left.stats.recency_weighted_score
+      || fallbackOrder(left.candidate, left.index) - fallbackOrder(right.candidate, right.index)
+      || candidateId(left.candidate).localeCompare(candidateId(right.candidate)))
+    .map((entry) => entry.candidate);
+  return {
+    candidates: ranked,
+    stats,
+    task_type: taskType,
+    used_track_record: true,
+    thin_engines: [],
+  };
+}
+
+function rankEngines(candidates, options = {}) {
+  return rankEnginesDetailed(candidates, options).candidates;
+}
+
+function routerPickExplanation(decision) {
+  const winner = decision?.candidates?.[0];
+  const engine = candidateId(winner);
+  if (!engine) return '';
+  const taskType = normalizedLabel(decision.task_type) || 'work';
+  if (!decision.used_track_record) {
+    return `router picked ${engine} because ${taskType} track records are thin, so fallback order applies.`;
+  }
+  const stats = decision.stats.find((row) => row.engine === engine && row.task_type === taskType);
+  if (!stats) return `router picked ${engine} because it has the strongest ${taskType} track record.`;
+  const passRate = (stats.verified_pass_rate * 100).toFixed(1);
+  const duration = stats.median_duration_ms === null ? 'no duration' : `${Math.round(stats.median_duration_ms)} ms median`;
+  return `router picked ${engine} because ${stats.receipt_count} ${taskType} receipts scored ${stats.recency_weighted_score.toFixed(3)} with a ${passRate}% verified pass rate and ${duration}.`;
+}
+
+module.exports = {
+  DEFAULT_MIN_RECEIPTS,
+  DEFAULT_HALF_LIFE_MS,
+  loadRouterHistory,
+  computeEngineTaskStats,
+  rankEngines,
+  rankEnginesDetailed,
+  routerPickExplanation,
+};

package/lib/runner-command.js

@@ -62,11 +62,21 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     model: '',
     commandTemplate: '{bin} -p -- {prompt}',
   }),
+  grok: Object.freeze({
+    bin: 'grok',
+    model: 'grok-4.5',
+    commandTemplate: '{bin} --always-approve -p {prompt}',
+  }),
   hermes: Object.freeze({
     bin: 'hermes',
     model: '',
     commandTemplate: '{bin} -p -- {prompt}',
   }),
+  droid: Object.freeze({
+    bin: 'droid',
+    model: '',
+    commandTemplate: '{bin} exec {prompt}',
+  }),
 });
 
 // Alias -> canonical profile name. Every alias resolves to the same config as