atris 3.61.0 → 3.62.0

package/lib/roster-runs.js

@@ -0,0 +1,389 @@
+'use strict';
+
+// One line per run launched from a roster pick, so the owner can judge each
+// tool and model on real work instead of memory. A line says when, which job,
+// which member (if any), the engine, model, effort, time cap, seconds taken,
+// and how it ended: landed, failed, stalled, credit out, and who took over
+// when it was handed on. Tokens and cost appear only when the tool printed
+// them in output we already capture; nothing is guessed.
+//
+// Writing never throws into the run that called it, and reading only looks
+// at the tail of each file, skipping any line that does not parse.
+
+const fs = require('fs');
+const path = require('path');
+
+const RUNS_FILE = path.join('.atris', 'state', 'roster_runs.jsonl');
+// Rotated logs sit beside the live one, named roster_runs.<UTC stamp to the
+// millisecond>-<pid>.jsonl so two writers rotating in the same breath can
+// never rename onto each other. The name starts with a digit so the legacy
+// roster_runs.1.jsonl still counts and roster_runs.pending.jsonl does not.
+const ROTATED_NAME = /^roster_runs\.\d.*\.jsonl$/;
+const ROTATED_KEEP = 3;
+const ROTATED_READ = 2;
+const OUTCOMES = Object.freeze(['landed', 'failed', 'stalled', 'credit out']);
+const DEFAULT_DAYS = 7;
+const TAIL_BYTES = 512 * 1024;
+// Past this size the log is renamed aside before the append, never trimmed:
+// rotation moves whole records instead of cutting the oldest ones away.
+const RUNS_ROTATE_BYTES = 2 * 1024 * 1024;
+const JOB_ALIASES = Object.freeze({ navigator: 'search', executor: 'build', builder: 'build', validator: 'review', reviewer: 'review' });
+
+function rosterRunsPath(root = process.cwd()) {
+  return path.join(root, RUNS_FILE);
+}
+
+// Rotated logs, oldest name first; the stamp in each name makes name order
+// the order they were renamed in.
+function rotatedRunsPaths(root = process.cwd()) {
+  const dir = path.dirname(path.join(root, RUNS_FILE));
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.filter((name) => ROTATED_NAME.test(name)).sort().map((name) => path.join(dir, name));
+}
+
+function nowMs(now) {
+  if (now instanceof Date) return now.getTime();
+  if (typeof now === 'function') return nowMs(now());
+  const value = Number(now);
+  return Number.isFinite(value) && now !== null && now !== undefined ? value : Date.now();
+}
+
+function clean(value) {
+  return String(value == null ? '' : value).replace(/\s+/g, ' ').trim();
+}
+
+// "executor", "small-build", and "Small Build" all read as the job's name.
+function jobName(value) {
+  const text = clean(value).toLowerCase().replace(/[-_]+/g, ' ');
+  return JOB_ALIASES[text] || text;
+}
+
+function wholeNumber(value) {
+  const number = Number(String(value == null ? '' : value).replace(/,/g, ''));
+  return Number.isFinite(number) && number >= 0 ? Math.round(number) : null;
+}
+
+function usageTotal(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const parts = ['input_tokens', 'output_tokens', 'cache_creation_input_tokens', 'cache_read_input_tokens']
+    .map((key) => wholeNumber(usage[key]))
+    .filter((value) => value !== null);
+  return parts.length ? parts.reduce((sum, value) => sum + value, 0) : null;
+}
+
+// Tokens and cost the tool itself reported, or nothing. Claude's json result
+// carries usage and total_cost_usd; codex prints "tokens used" and the count.
+function parseRunUsage({ usage = null, cost_usd = null, stdout = '', stderr = '' } = {}) {
+  const found = {};
+  const direct = usageTotal(usage);
+  if (direct !== null) found.tokens = direct;
+  if (typeof cost_usd === 'number' && Number.isFinite(cost_usd)) found.cost_usd = cost_usd;
+  const text = `${String(stdout || '')}\n${String(stderr || '')}`;
+  if (found.tokens === undefined) {
+    for (const line of text.split(/\r?\n/).reverse()) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('{') || !trimmed.includes('"usage"')) continue;
+      try {
+        const event = JSON.parse(trimmed);
+        const tokens = usageTotal(event && event.usage);
+        if (tokens === null) continue;
+        found.tokens = tokens;
+        if (found.cost_usd === undefined && typeof event.total_cost_usd === 'number') found.cost_usd = event.total_cost_usd;
+        break;
+      } catch {}
+    }
+  }
+  if (found.tokens === undefined) {
+    const codex = /tokens used[:\s]*([\d,]+)/gi;
+    let match;
+    let last = null;
+    while ((match = codex.exec(text))) last = match[1];
+    const tokens = wholeNumber(last);
+    if (last && tokens !== null) found.tokens = tokens;
+  }
+  return found;
+}
+
+// One normalized line. Empty fields stay out so a line only says what we know.
+function normalizeRun(input = {}, { now } = {}) {
+  const outcome = OUTCOMES.includes(input.outcome) ? input.outcome : 'failed';
+  const record = {
+    at: clean(input.at) || new Date(nowMs(now)).toISOString(),
+    job: jobName(input.job) || 'build',
+    engine: clean(input.engine) || 'unknown',
+    outcome,
+  };
+  const optional = {
+    member: clean(input.member),
+    model: clean(input.model),
+    effort: clean(input.effort),
+    task: clean(input.task),
+    detail: clean(input.detail).slice(0, 240),
+    handed_over_to: clean(input.handed_over_to),
+    source: clean(input.source),
+    prep: clean(input.prep).slice(0, 160),
+  };
+  for (const [key, value] of Object.entries(optional)) if (value) record[key] = value;
+  const cap = wholeNumber(input.max_seconds);
+  if (cap) record.max_seconds = cap;
+  const seconds = Number(input.seconds);
+  if (Number.isFinite(seconds) && seconds >= 0) record.seconds = Math.round(seconds);
+  const tokens = wholeNumber(input.tokens);
+  if (input.tokens !== undefined && input.tokens !== null && tokens !== null) record.tokens = tokens;
+  if (typeof input.cost_usd === 'number' && Number.isFinite(input.cost_usd)) record.cost_usd = input.cost_usd;
+  for (const key of ['brief_lines', 'brief_bytes']) {
+    const value = wholeNumber(input[key]);
+    if (input[key] !== undefined && input[key] !== null && value !== null) record[key] = value;
+  }
+  return record;
+}
+
+// Past the cap, the log moves aside under a fresh stamped name, so a second
+// writer rotating in the same breath adds a file instead of replacing one.
+// A rename that fails, including ENOENT when another writer got there
+// first, deletes nothing: the append still lands in the live log. Only
+// after a rename lands are rotated files past the newest few removed.
+function rotateRunsFile(root, file, options = {}) {
+  let size = 0;
+  try {
+    size = fs.statSync(file).size;
+  } catch {
+    return;
+  }
+  if (size < RUNS_ROTATE_BYTES) return;
+  const dir = path.dirname(file);
+  const stamp = new Date(nowMs(options.now)).toISOString().replace(/[-:]/g, '');
+  let rotated = path.join(dir, `roster_runs.${stamp}-${process.pid}.jsonl`);
+  for (let attempt = 1; fs.existsSync(rotated); attempt += 1) {
+    rotated = path.join(dir, `roster_runs.${stamp}-${process.pid}-${attempt}.jsonl`);
+  }
+  try {
+    fs.renameSync(file, rotated);
+  } catch {
+    return;
+  }
+  const rotatedFiles = rotatedRunsPaths(root);
+  for (const old of rotatedFiles.slice(0, Math.max(0, rotatedFiles.length - ROTATED_KEEP))) {
+    try { fs.rmSync(old, { force: true }); } catch {}
+  }
+}
+
+// One whole line per call, no lock. Before the append, a log at the cap
+// rotates aside so every record stays readable, and recording never throws
+// into the run that made it.
+function appendRosterRun(root = process.cwd(), input = {}, options = {}) {
+  try {
+    const record = normalizeRun(input, options);
+    const file = rosterRunsPath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    rotateRunsFile(root, file, options);
+    fs.appendFileSync(file, `${JSON.stringify(record)}\n`, 'utf8');
+    return record;
+  } catch {
+    return null;
+  }
+}
+
+// Several attempts at one job, oldest first. Each attempt that was followed by
+// another names who took over.
+function appendRosterAttempts(root, attempts = [], shared = {}, options = {}) {
+  const list = (attempts || []).filter(Boolean);
+  return list.map((attempt, index) => appendRosterRun(root, {
+    ...shared,
+    ...attempt,
+    ...(index + 1 < list.length && list[index + 1].engine ? { handed_over_to: list[index + 1].engine } : {}),
+  }, options));
+}
+
+// The last few hundred KB only: the file grows forever and the roster view
+// never needs more than recent days.
+function readTail(file, bytes = TAIL_BYTES) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const size = fs.fstatSync(fd).size;
+    const start = Math.max(0, size - bytes);
+    const buffer = Buffer.alloc(size - start);
+    fs.readSync(fd, buffer, 0, buffer.length, start);
+    const text = buffer.toString('utf8');
+    return start > 0 ? text.slice(text.indexOf('\n') + 1) : text;
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) try { fs.closeSync(fd); } catch {}
+  }
+}
+
+const TEXT_FIELDS = Object.freeze(['at', 'job', 'engine', 'outcome', 'member', 'model', 'effort', 'task', 'detail', 'handed_over_to', 'source', 'prep']);
+const NUMBER_FIELDS = Object.freeze(['max_seconds', 'seconds', 'tokens', 'cost_usd', 'brief_lines', 'brief_bytes']);
+
+// A line as read back, with every known field its expected type: text
+// trimmed or dropped, numbers finite or dropped ("0.42" reads as 0.42), so a
+// hand-edited line can never break the views.
+function readableRun(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (TEXT_FIELDS.includes(key)) {
+      if (typeof value !== 'string') continue;
+      const text = value.trim();
+      if (text) out[key] = text;
+    } else if (NUMBER_FIELDS.includes(key)) {
+      const number = typeof value === 'number' ? value
+        : typeof value === 'string' && value.trim() ? Number(value.trim())
+          : NaN;
+      if (Number.isFinite(number) && number >= 0) out[key] = number;
+    }
+  }
+  return out;
+}
+
+// Runs from the last `days` days, oldest first, read from the last
+// `tailBytes` of each file. A missing file or a bad line is never an error.
+function readRosterRuns(root = process.cwd(), { now, days = DEFAULT_DAYS, tailBytes = TAIL_BYTES } = {}) {
+  const since = nowMs(now) - Math.max(0, Number(days) || DEFAULT_DAYS) * 86400000;
+  const rows = [];
+  const bytes = Number(tailBytes) > 0 ? Number(tailBytes) : TAIL_BYTES;
+  // The newest rotated files hold the older records. A read that races a
+  // rotation can miss a file for that one read; the next read sees it, and
+  // these records only feed suggestions and ranking, so a miss costs
+  // nothing.
+  for (const file of [...rotatedRunsPaths(root).slice(-ROTATED_READ), rosterRunsPath(root)]) {
+    for (const line of readTail(file, bytes).split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      let row;
+      try {
+        row = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!row || typeof row !== 'object' || Array.isArray(row)) continue;
+      row = readableRun(row);
+      if (!row.engine || !OUTCOMES.includes(row.outcome)) continue;
+      const at = Date.parse(row.at);
+      if (!Number.isFinite(at) || at < since) continue;
+      rows.push(row);
+    }
+  }
+  return rows;
+}
+
+function median(values) {
+  const sorted = values.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
+  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 durationText(seconds) {
+  const value = Math.round(Number(seconds) || 0);
+  if (value < 60) return `${value}s`;
+  if (value < 3600) return `${Math.round(value / 60)} min`;
+  const hours = Math.floor(value / 3600);
+  const minutes = Math.round((value % 3600) / 60);
+  return minutes ? `${hours} h ${minutes} min` : `${hours} h`;
+}
+
+// The runs that belong to one worker on one job. A worker with a pinned model
+// counts only runs on that model; with no pin, every run of the engine counts.
+function workerRuns(runs, { job, engine, model = '' } = {}) {
+  const wantJob = jobName(job);
+  const wantEngine = clean(engine);
+  const wantModel = clean(model).toLowerCase();
+  return (runs || []).filter((run) => jobName(run.job) === wantJob
+    && run.engine === wantEngine
+    && (!wantModel || clean(run.model).toLowerCase() === wantModel));
+}
+
+// "last 7 days: 9 runs, 7 landed, 1 stalled, 1 failed, median 11 min", or
+// null when there are no runs.
+function summarizeRuns(runs, { days = DEFAULT_DAYS } = {}) {
+  const list = runs || [];
+  if (!list.length) return null;
+  const count = (outcome) => list.filter((run) => run.outcome === outcome).length;
+  const summary = {
+    days,
+    runs: list.length,
+    landed: count('landed'),
+    failed: count('failed'),
+    stalled: count('stalled'),
+    credit_out: count('credit out'),
+    handed_over: list.filter((run) => run.handed_over_to).length,
+    median_seconds: median(list.map((run) => Number(run.seconds)).filter((value) => value >= 0)),
+  };
+  const tokens = list.map((run) => run.tokens).filter((value) => Number.isFinite(value));
+  if (tokens.length) summary.tokens = tokens.reduce((sum, value) => sum + value, 0);
+  const parts = [`${summary.runs} run${summary.runs === 1 ? '' : 's'}`];
+  if (summary.landed) parts.push(`${summary.landed} landed`);
+  if (summary.stalled) parts.push(`${summary.stalled} stalled`);
+  if (summary.failed) parts.push(`${summary.failed} failed`);
+  if (summary.credit_out) parts.push(`${summary.credit_out} credit out`);
+  if (summary.median_seconds !== null) parts.push(`median ${durationText(summary.median_seconds)}`);
+  summary.text = `last ${days} day${days === 1 ? '' : 's'}: ${parts.join(', ')}`;
+  return summary;
+}
+
+function clockText(at) {
+  const date = new Date(at);
+  if (!Number.isFinite(date.getTime())) return String(at || '');
+  const day = date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }).toLowerCase();
+  return `${day} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+
+function briefSizeText(bytes) {
+  const value = Number(bytes) || 0;
+  return value < 1024 ? `${value} bytes` : `${(value / 1024).toFixed(1).replace(/\.0$/, '')} KB`;
+}
+
+function outcomeText(run) {
+  let text = run.outcome;
+  if (run.detail && run.detail !== run.outcome) text = run.outcome === 'stalled' && /^stalled\b/.test(run.detail) ? run.detail : `${run.outcome}, ${run.detail}`;
+  if (run.handed_over_to) text += `, handed over to ${run.handed_over_to}`;
+  if (run.prep) text += `, ${run.prep}${run.brief_bytes ? ` (${briefSizeText(run.brief_bytes)} brief)` : ''}`;
+  return text;
+}
+
+// One plain line per attempt.
+function renderRunLine(run) {
+  const worker = [run.engine, run.model, run.effort].filter(Boolean).join(' ');
+  const facts = [
+    run.seconds !== undefined ? durationText(run.seconds) : '',
+    run.max_seconds ? `cap ${durationText(run.max_seconds)}` : '',
+    run.tokens !== undefined ? `${run.tokens.toLocaleString('en-US')} tokens` : '',
+    run.cost_usd !== undefined ? `$${run.cost_usd.toFixed(2)}` : '',
+  ].filter(Boolean).join(', ');
+  const who = [run.job, run.member ? `for ${run.member}` : '', run.task].filter(Boolean).join(' ');
+  return `${clockText(run.at)}  ${who}: ${worker}${facts ? ` (${facts})` : ''}, ${outcomeText(run)}`;
+}
+
+// Newest first, at most `limit`, optionally one job only.
+function recentRuns(runs, { job = '', limit = 20 } = {}) {
+  const wantJob = job ? jobName(job) : '';
+  return (runs || [])
+    .filter((run) => !wantJob || jobName(run.job) === wantJob)
+    .map((run, index) => ({ run, index }))
+    .sort((a, b) => (Date.parse(b.run.at) - Date.parse(a.run.at)) || (b.index - a.index))
+    .slice(0, limit)
+    .map(({ run }) => run);
+}
+
+module.exports = {
+  OUTCOMES,
+  DEFAULT_DAYS,
+  RUNS_ROTATE_BYTES,
+  rosterRunsPath,
+  rotatedRunsPaths,
+  jobName,
+  parseRunUsage,
+  appendRosterRun,
+  appendRosterAttempts,
+  readRosterRuns,
+  workerRuns,
+  summarizeRuns,
+  renderRunLine,
+  recentRuns,
+};

package/lib/roster-suggest.js

@@ -0,0 +1,145 @@
+'use strict';
+
+// Suggestions from the run record. When a job's first worker keeps stalling
+// or failing and a worker further down its list keeps landing, the roster
+// view says so once, with the command that would move the better worker up.
+// Nothing here writes ROSTER.md: only a person (or a person telling an
+// agent) changes the roster. This file only reads runs and words a line.
+
+const { readRosterRuns, workerRuns } = require('./roster-runs');
+const { rosterToolLabel } = require('./engine-registry');
+
+// Only the last week counts, and within it each worker's newest few runs.
+const SUGGEST_DAYS = 7;
+const SUGGEST_WINDOW_RUNS = 5;
+// The lead needs enough runs to judge; the challenger needs at least two.
+const SUGGEST_MIN_LEAD_RUNS = 3;
+const SUGGEST_MIN_CHALLENGER_RUNS = 2;
+// The lead lands under half its runs, and the challenger's landed rate is
+// at least 25 points higher.
+const SUGGEST_LEAD_BELOW_POINTS = 50;
+const SUGGEST_MIN_GAP_POINTS = 25;
+// The boot line reads only this much of the end of the record.
+const BOOT_TAIL_BYTES = 64 * 1024;
+
+// A credit wall says nothing about how well a worker does the job, and
+// engine health already benches it, so credit out runs are left out.
+function judgedRuns(runs) {
+  return runs
+    .filter((run) => run.outcome !== 'credit out')
+    .map((run, index) => ({ run, index }))
+    .sort((a, b) => (Date.parse(b.run.at) - Date.parse(a.run.at)) || (b.index - a.index))
+    .slice(0, SUGGEST_WINDOW_RUNS)
+    .map(({ run }) => run);
+}
+
+function tally(runs) {
+  const landed = runs.filter((run) => run.outcome === 'landed').length;
+  return { runs: runs.length, landed };
+}
+
+function workerName(worker) {
+  if (worker.runs && worker.runs.text) return worker.runs.text;
+  return [rosterToolLabel(worker.engine), worker.model].filter(Boolean).join(' ');
+}
+
+function quoteArg(value) {
+  const text = String(value);
+  return /^[a-z0-9._:/@+-]+$/i.test(text) ? text : `"${text.replace(/(["\\$`])/g, '\\$1')}"`;
+}
+
+// The assign command that moves the challenger to the top of the job. It
+// names the challenger's line exactly: the tool, plus its model and effort
+// when its line has them, so --promote moves that worker and no other line
+// of the same tool. --promote reorders lines as written, so the demoted
+// lead keeps its own cap, prep, and notes.
+function assignArgs(job, challenger) {
+  const words = [rosterToolLabel(challenger.engine), challenger.model, challenger.effort].filter(Boolean).join(' ');
+  return ['assign', job, '--promote', words];
+}
+
+function leadText(name, count) {
+  const missed = count.runs - count.landed;
+  const outcomes = [...new Set(count.list.filter((run) => run.outcome !== 'landed').map((run) => run.outcome))];
+  const last = `of its last ${count.runs} run${count.runs === 1 ? '' : 's'}`;
+  if (missed && outcomes.length === 1) return `${name} ${outcomes[0]} ${missed} ${last}`;
+  return `${name} landed ${count.landed} ${last}`;
+}
+
+// At most one suggestion for one job row of the roster report, or null. A
+// row's workers carry their status: a worker that is cooling, expired, not
+// ready, or on a bad line is skipped and is never suggested.
+function jobSuggestion(row, runs) {
+  if (!row || !row.pick || !Array.isArray(row.workers) || row.workers.length < 2) return null;
+  const job = row.key || row.job;
+  const usable = row.workers.filter((worker) => worker.engine && !worker.text);
+  const lead = usable[0];
+  if (!lead) return null;
+  const countFor = (worker) => {
+    const list = judgedRuns(workerRuns(runs, { job, engine: worker.engine, model: worker.model || '' }));
+    return { ...tally(list), list };
+  };
+  const leadCount = countFor(lead);
+  if (leadCount.runs < SUGGEST_MIN_LEAD_RUNS) return null;
+  if (leadCount.landed * 100 >= SUGGEST_LEAD_BELOW_POINTS * leadCount.runs) return null;
+  let best = null;
+  for (const worker of usable.slice(1)) {
+    if (worker.status === 'skipped') continue;
+    const count = countFor(worker);
+    if (count.runs < SUGGEST_MIN_CHALLENGER_RUNS) continue;
+    // Whole-number math: the challenger's rate minus the lead's, in points.
+    const gap = 100 * (count.landed * leadCount.runs - leadCount.landed * count.runs);
+    if (gap < SUGGEST_MIN_GAP_POINTS * leadCount.runs * count.runs) continue;
+    const rate = count.landed / count.runs;
+    if (!best || rate > best.rate || (rate === best.rate && count.runs > best.count.runs)) best = { worker, count, rate };
+  }
+  if (!best) return null;
+  const leadName = workerName(lead);
+  const challengerName = workerName(best.worker);
+  const args = assignArgs(row.job, best.worker);
+  const command = `atris engine ${args.map(quoteArg).join(' ')}`;
+  const record = `${leadText(leadName, leadCount)}; ${challengerName} landed ${best.count.landed} of ${best.count.runs}`;
+  return {
+    job: row.job,
+    days: SUGGEST_DAYS,
+    lead: { engine: lead.engine, model: lead.model || null, runs: leadCount.runs, landed: leadCount.landed },
+    challenger: { engine: best.worker.engine, model: best.worker.model || null, runs: best.count.runs, landed: best.count.landed },
+    command,
+    args,
+    text: `${record}. to move ${rosterToolLabel(best.worker.engine)} up: ${command}`,
+  };
+}
+
+// Attach a suggestion to each job row that has one. Returns how many.
+function attachSuggestions(jobs, runs) {
+  let count = 0;
+  for (const row of jobs || []) {
+    const suggestion = jobSuggestion(row, runs);
+    if (suggestion) {
+      row.suggestion = suggestion;
+      count += 1;
+    }
+  }
+  return count;
+}
+
+// How many jobs have a suggestion, reading only the end of the record. For
+// the boot line: never throws, 0 when anything goes wrong.
+function suggestionCount(jobs, root, { now } = {}) {
+  try {
+    const runs = readRosterRuns(root, { now, days: SUGGEST_DAYS, tailBytes: BOOT_TAIL_BYTES });
+    if (!runs.length) return 0;
+    return (jobs || []).filter((row) => jobSuggestion(row, runs)).length;
+  } catch {
+    return 0;
+  }
+}
+
+module.exports = {
+  SUGGEST_MIN_LEAD_RUNS,
+  SUGGEST_MIN_CHALLENGER_RUNS,
+  SUGGEST_LEAD_BELOW_POINTS,
+  SUGGEST_MIN_GAP_POINTS,
+  attachSuggestions,
+  suggestionCount,
+};

package/lib/router-brain.js

@@ -85,6 +85,18 @@ function recordTimestamp(containers, fallbackMs) {
   return Number.isFinite(fallbackMs) ? fallbackMs : Date.now();
 }
 
+// The id a receipt and a roster run record share for the same attempt: the
+// task id (`task`, `task_id`), else the brief id. '' means the record names
+// nothing shared, so it can never be deduped against another.
+function recordRunRef(containers) {
+  const raw = firstField(
+    containers,
+    ['task_id', 'taskId', 'task', 'brief_id', 'briefId', 'run_id', 'runId'],
+    (value) => (typeof value === 'string' && value.trim()) || typeof value === 'number',
+  );
+  return raw === null ? '' : normalizedLabel(raw);
+}
+
 function observationFromRecord(record, source, fallbackMs) {
   const containers = recordContainers(record);
   const engine = normalizedLabel(firstField(containers, [
@@ -115,6 +127,7 @@ function observationFromRecord(record, source, fallbackMs) {
     duration_ms: recordDuration(containers),
     at_ms: recordTimestamp(containers, fallbackMs),
     source,
+    run_ref: recordRunRef(containers),
   };
 }
 
@@ -188,12 +201,107 @@ function readDispatchReceiptObservations(root) {
   return observations;
 }
 
-function loadRouterHistory(root = process.cwd()) {
-  return [
+// Roster runs (.atris/state/roster_runs.jsonl) as one more signal, for jobs
+// the router ranks because no roster line picks for them. Each run counts as
+// one receipt, the same weight and the same 30-day half-life as a task
+// receipt: landed is a pass; stalled and failed are a miss. Credit out is
+// left out, since engine health already benches that worker. The job name
+// maps to the role the router ranks by: build to executor, search to
+// navigator, review to validator, and an owner's job by its last word
+// ("small build" is build work). No record file means no observations, so
+// the ranking is exactly what it was without one.
+const ROSTER_RUN_DAYS = 30;
+const ROSTER_JOB_ROLES = Object.freeze({ build: 'executor', search: 'navigator', review: 'validator' });
+
+function readRosterRunObservations(root, now) {
+  const { readRosterRuns, rosterRunsPath, rotatedRunsPaths } = require('./roster-runs');
+  const file = rosterRunsPath(root);
+  if (!fs.existsSync(file) && !rotatedRunsPaths(root).length) return [];
+  const source = path.relative(root, file);
+  return readRosterRuns(root, { days: ROSTER_RUN_DAYS, ...(now !== undefined ? { now } : {}) }).flatMap((run) => {
+    if (run.outcome === 'credit out') return [];
+    const words = String(run.job || '').trim().toLowerCase().split(/\s+/);
+    const role = ROSTER_JOB_ROLES[words[words.length - 1]];
+    const atMs = Date.parse(run.at);
+    if (!role || !Number.isFinite(atMs)) return [];
+    return [{
+      engine: normalizedLabel(run.engine),
+      task_type: role,
+      verified_passed: run.outcome === 'landed',
+      duration_ms: Number.isFinite(run.seconds) ? run.seconds * 1000 : null,
+      at_ms: atMs,
+      source,
+      run_ref: normalizedLabel(run.task),
+    }];
+  });
+}
+
+// One landed dispatch writes both a receipt result row and a roster run
+// record for the same attempt. The shared id is the task id; the receipt
+// stamps the moment the run ended, the run record the moment it started.
+// Same engine, same task id, a few minutes apart at either end means one
+// run, and the receipt wins because its verified flag is authoritative.
+// A receipt can pair with a run near either end, which is two separate
+// windows per run, so no greedy order is safe. Each task id and engine
+// group is tiny, so pairing uses exact maximum matching (augmenting paths):
+// the pair count is maximal, one receipt cancels at most one run, a pair
+// counts once, and a run or receipt left over still counts once on its own.
+// A retry after a landed run is its own attempt and still counts.
+const RUN_RECEIPT_WINDOW_MS = 5 * 60 * 1000;
+
+// How far the receipt sits from the run's start or finish; the nearer end
+// decides whether they describe the same attempt.
+function receiptRunGap(receipt, run) {
+  const end = Number.isFinite(run.duration_ms) ? run.at_ms + run.duration_ms : run.at_ms;
+  return Math.min(Math.abs(receipt.at_ms - run.at_ms), Math.abs(receipt.at_ms - end));
+}
+
+// Maximum matching between receipt and run indexes, where canPair says
+// whether a receipt and a run may describe the same attempt. Returns the
+// set of paired run indexes.
+function maxPairedRuns(receiptIds, runIds, canPair) {
+  const runOwner = new Map();
+  const tryReceipt = (r, seen) => {
+    for (const n of runIds) {
+      if (seen.has(n) || !canPair(r, n)) continue;
+      seen.add(n);
+      if (!runOwner.has(n) || tryReceipt(runOwner.get(n), seen)) {
+        runOwner.set(n, r);
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const r of receiptIds) tryReceipt(r, new Set());
+  return new Set(runOwner.keys());
+}
+
+function loadRouterHistory(root = process.cwd(), { now } = {}) {
+  const receipts = [
     ...readTaskReceiptObservations(root),
     ...readMissionEventObservations(root),
     ...readDispatchReceiptObservations(root),
   ];
+  const runs = readRosterRunObservations(root, now);
+  const groups = new Map();
+  for (const [r, receipt] of receipts.entries()) {
+    if (!receipt.run_ref) continue;
+    const key = `${receipt.engine}\u0000${receipt.run_ref}`;
+    if (!groups.has(key)) groups.set(key, { receipts: [], runs: [] });
+    groups.get(key).receipts.push(r);
+  }
+  for (const [n, run] of runs.entries()) {
+    if (!run.run_ref) continue;
+    const group = groups.get(`${run.engine}\u0000${run.run_ref}`);
+    if (group) group.runs.push(n);
+  }
+  const pairedRuns = new Set();
+  const canPair = (r, n) => receiptRunGap(receipts[r], runs[n]) <= RUN_RECEIPT_WINDOW_MS;
+  for (const group of groups.values()) {
+    for (const n of maxPairedRuns(group.receipts, group.runs, canPair)) pairedRuns.add(n);
+  }
+  return [...receipts, ...runs.filter((run, n) => !pairedRuns.has(n))]
+    .map(({ run_ref, ...observation }) => observation);
 }
 
 function median(values) {
@@ -290,7 +398,7 @@ function rankEnginesDetailed(candidates, options = {}) {
   const minReceipts = Number.isInteger(minValue) && minValue > 0 ? minValue : DEFAULT_MIN_RECEIPTS;
   const observations = Array.isArray(options.observations)
     ? options.observations
-    : loadRouterHistory(options.root || process.cwd());
+    : loadRouterHistory(options.root || process.cwd(), { now: options.now });
   const stats = computeEngineTaskStats(observations, options);
   const statsByEngine = new Map(stats
     .filter((row) => row.task_type === taskType)