atris 3.65.0 → 3.67.0

package/lib/land-green.js

@@ -23,6 +23,9 @@ const { runGit } = require('./git-spawn');
 
 const DEFAULT_VERIFY = 'npm test';
 const DEFAULT_VERIFY_TIMEOUT_MS = 20 * 60 * 1000;
+// Stop the walk after this many consecutive branches that landed nothing, so
+// a queue of erroring branches does not burn a scratch checkout per branch.
+const DEFAULT_MAX_MISSES = 4;
 const FAILING_LINE = /^(?:✖|not ok)\s+(.+?)(?:\s+\(\d+(?:\.\d+)?ms\))?\s*$/;
 
 function gitOut(args, cwd) {
@@ -291,6 +294,7 @@ function landStaleGreenBranches(root, {
   ttlDays,
   base: baseOverride = '',
   limit = 1,
+  maxMisses = DEFAULT_MAX_MISSES,
   now = Date.now(),
   verifyCommand = DEFAULT_VERIFY,
   verifyTimeoutMs = DEFAULT_VERIFY_TIMEOUT_MS,
@@ -307,19 +311,29 @@ function landStaleGreenBranches(root, {
     .filter((b) => b.state === 'active' && b.stale)
     .sort((a, b) => b.activityHours - a.activityHours);
   const verdicts = [];
-  let attempts = 0;
+  // Only landed and red verdicts spend the per-tick budget: an erroring or
+  // ineligible branch must not starve the rest of the queue. A bounded run of
+  // misses still stops the walk so a fully broken queue does not burn a
+  // scratch checkout per branch per tick.
+  let spent = 0;
+  let misses = 0;
   for (const candidate of candidates) {
-    if (attempts >= limit) {
-      verdicts.push(verdictFor(candidate.name, live.base, { action: 'skipped', reason: 'per_tick_limit' }));
+    if (spent >= limit || misses >= maxMisses) {
+      verdicts.push(verdictFor(candidate.name, live.base, { action: 'skipped', reason: spent >= limit ? 'per_tick_limit' : 'attempt_cap' }));
       continue;
     }
-    attempts += 1;
     let verdict;
     try {
       verdict = landOneBranch(root, live.base, candidate.name, { verifyCommand, verifyTimeoutMs, dryRun, push, runVerifyFn, env });
     } catch (err) {
       verdict = verdictFor(candidate.name, live.base, { action: 'error', reason: 'exception', detail: String((err && err.message) || err).slice(0, 300) });
     }
+    if (verdict.action === 'landed' || verdict.action === 'red') {
+      spent += 1;
+      misses = 0;
+    } else {
+      misses += 1;
+    }
     if (verdict.action === 'red' && openFlags) {
       try {
         const flagged = openRedFlag(root, verdict, { runCli });

package/lib/member-result.js

@@ -0,0 +1,303 @@
+'use strict';
+
+// atris member result <member> [--since <iso-time>] [--json]
+//
+// Reads back the newest real result of a member run as one object: the run
+// line from the roster's run record, the newest receipt in the member's
+// logs/, the files it made under work/, and one result number when the
+// receipt states one plainly. Read only.
+//
+// A member run usually works in its own git worktree, so its receipt and
+// files land there, not in the main checkout. The run's mission id leads to
+// that worktree; both places are read, newest file wins.
+
+const fs = require('fs');
+const path = require('path');
+
+const { readRosterRuns } = require('./roster-runs');
+
+const MEMBER_NAME_RE = /^[a-zA-Z0-9._-]+$/;
+const RUN_DAYS = 90;
+const RECEIPT_LINES = 40;
+const ARTIFACT_LINES = 20;
+const MAX_ARTIFACTS = 50;
+const MAX_WALK_FILES = 2000;
+const HEAD_READ_BYTES = 64 * 1024;
+const SKIP_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.venv', 'venv']);
+
+function usage() {
+  return [
+    'usage:',
+    '  atris member result <member> [--since <iso-time>] [--json]',
+    '',
+    'newest result of a member run: run record, receipt, artifacts, and one result number.',
+    '',
+    'options:',
+    '  --since <iso-time>  only files changed after this time (default: start of the newest run)',
+    '  --json              print the result as json',
+  ].join('\n');
+}
+
+function parseResultArgs(args = []) {
+  let member = '';
+  let since = '';
+  let json = false;
+  let help = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index]);
+    if (arg === '--help' || arg === '-h') { help = true; continue; }
+    if (arg === '--json') { json = true; continue; }
+    if (arg === '--since') {
+      if (index + 1 >= args.length) throw new Error('--since needs an iso time');
+      since = String(args[index + 1]);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--since=')) { since = arg.slice('--since='.length); continue; }
+    if (arg.startsWith('--')) throw new Error(`unknown option ${arg}`);
+    if (member) throw new Error(usage());
+    member = arg.trim();
+  }
+  if (help) return { help: true, json };
+  if (!member) throw new Error(usage());
+  if (!MEMBER_NAME_RE.test(member)) throw new Error(`"${member}" is not a member name`);
+  if (since && !Number.isFinite(Date.parse(since))) throw new Error(`--since "${since}" is not a time; use an iso time like 2026-10-02T18:00:00Z`);
+  return { help: false, member, since, json };
+}
+
+// The member's newest run line. `id` is the mission id the run worked on.
+function newestMemberRun(root, member, { now } = {}) {
+  const runs = readRosterRuns(root, { now, days: RUN_DAYS })
+    .filter((run) => run.member === member && Number.isFinite(Date.parse(run.at)));
+  if (!runs.length) return null;
+  runs.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const run = runs[runs.length - 1];
+  const startedMs = Date.parse(run.at);
+  const seconds = Number.isFinite(Number(run.seconds)) ? Number(run.seconds) : null;
+  return {
+    id: run.task || null,
+    started: new Date(startedMs).toISOString(),
+    ended: seconds === null ? null : new Date(startedMs + seconds * 1000).toISOString(),
+    status: run.outcome,
+    engine: run.engine,
+    model: run.model || null,
+    seconds,
+    ...(run.detail ? { detail: run.detail } : {}),
+  };
+}
+
+// Where the run's mission lives when that is a sibling worktree, else null.
+function runWorktreeRoot(root, missionId, deps = {}) {
+  if (!missionId) return null;
+  try {
+    const listRolled = deps.listWorktreeRollupMissions
+      || require('../commands/mission').listWorktreeRollupMissions;
+    const found = listRolled(root).find((mission) => mission && mission.id === missionId);
+    if (!found || !found.worktree_root || !fs.existsSync(found.worktree_root)) return null;
+    return path.resolve(found.worktree_root);
+  } catch {
+    return null;
+  }
+}
+
+// Files under dir changed after sinceMs, newest first. Bounded walk.
+function changedFiles(dir, sinceMs) {
+  const out = [];
+  const stack = [dir];
+  let seen = 0;
+  while (stack.length && seen < MAX_WALK_FILES) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name)) continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) { stack.push(full); continue; }
+      if (!entry.isFile()) continue;
+      seen += 1;
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      if (sinceMs !== null && stat.mtimeMs <= sinceMs) continue;
+      out.push({ path: full, size: stat.size, mtimeMs: stat.mtimeMs });
+    }
+  }
+  return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+// First n lines when the file reads as text, else null.
+function headLines(file, count) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const buffer = Buffer.alloc(HEAD_READ_BYTES);
+    const bytes = fs.readSync(fd, buffer, 0, HEAD_READ_BYTES, 0);
+    const chunk = buffer.subarray(0, bytes);
+    if (chunk.includes(0)) return null;
+    return chunk.toString('utf8').split(/\r?\n/).slice(0, count).join('\n').replace(/\s+$/, '');
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) try { fs.closeSync(fd); } catch {}
+  }
+}
+
+const COUNT_WORDS = [
+  'tests?', 'passed', 'checks?', 'files?', 'items?', 'rows?', 'leads?', 'replies', 'emails?', 'messages?',
+  'users?', 'customers?', 'signups?', 'clips?', 'shots?', 'scenes?', 'bugs?', 'errors?', 'issues?', 'tasks?',
+  'wins?', 'deals?', 'meetings?', 'calls?', 'views?', 'sales', 'orders?', 'bets?', 'pages?', 'questions?', 'answers?',
+].join('|');
+
+// One result number when the receipt states one plainly: a single distinct
+// percent, else a single dollar amount, else a single count of things. Two
+// different values of the same kind means none is the obvious one.
+function obviousNumber(text) {
+  const body = String(text || '');
+  const kinds = [
+    {
+      kind: 'percent',
+      re: /(?<![\w.$])(\d+(?:\.\d+)?)\s?(%|percent\b)/gi,
+      value: (match) => Number(match[1]),
+    },
+    {
+      kind: 'dollars',
+      re: /\$\s?(\d[\d,]*(?:\.\d+)?)(\s?[kKmM]\b)?/g,
+      value: (match) => {
+        const base = Number(match[1].replace(/,/g, ''));
+        const unit = String(match[2] || '').trim().toLowerCase();
+        return unit === 'k' ? base * 1000 : unit === 'm' ? base * 1000000 : base;
+      },
+    },
+    {
+      kind: 'count',
+      re: new RegExp(`(?<![\\w.:/#-])(\\d[\\d,]*)\\s+(?:of\\s+\\d[\\d,]*\\s+)?(?:${COUNT_WORDS})\\b`, 'gi'),
+      value: (match) => Number(match[1].replace(/,/g, '')),
+    },
+  ];
+  for (const { kind, re, value } of kinds) {
+    const found = new Map();
+    for (const match of body.matchAll(re)) {
+      const number = value(match);
+      if (!Number.isFinite(number)) continue;
+      if (!found.has(number)) found.set(number, match[0].trim());
+    }
+    if (found.size === 1) {
+      const [[number, textValue]] = [...found.entries()];
+      return { value: number, text: textValue, kind };
+    }
+    if (found.size > 1) return null;
+  }
+  return null;
+}
+
+function memberResult(root, member, { since = '', now, deps = {} } = {}) {
+  const run = newestMemberRun(root, member, { now });
+  const worktree = run ? runWorktreeRoot(root, run.id, deps) : null;
+  const roots = [...new Set([worktree, path.resolve(root)].filter(Boolean))];
+  const memberHere = roots.some((dir) => fs.existsSync(path.join(dir, 'atris', 'team', member)));
+  if (!run && !memberHere) return { ok: false, error: `no member named ${member} here, and no run of one on record` };
+
+  const sinceIso = since ? new Date(Date.parse(since)).toISOString() : (run ? run.started : null);
+  const sinceMs = sinceIso ? Date.parse(sinceIso) : null;
+
+  const logs = roots.flatMap((dir) => changedFiles(path.join(dir, 'atris', 'team', member, 'logs'), sinceMs));
+  logs.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const newestLog = logs[0] || null;
+  const receipt = newestLog ? {
+    path: newestLog.path,
+    modified: new Date(newestLog.mtimeMs).toISOString(),
+    head: headLines(newestLog.path, RECEIPT_LINES),
+  } : null;
+
+  // The member's work/ in every root; a run's own worktree also counts its
+  // top-level work/, since nothing else writes into that checkout.
+  const workDirs = roots.map((dir) => path.join(dir, 'atris', 'team', member, 'work'));
+  if (worktree) workDirs.push(path.join(worktree, 'work'));
+  const files = workDirs.flatMap((dir) => changedFiles(dir, sinceMs));
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const artifacts = files.slice(0, MAX_ARTIFACTS).map((file) => ({
+    path: file.path,
+    size: file.size,
+    modified: new Date(file.mtimeMs).toISOString(),
+    head: headLines(file.path, ARTIFACT_LINES),
+  }));
+
+  const number = receipt ? obviousNumber(receipt.head) : null;
+  return {
+    ok: true,
+    value: {
+      member,
+      since: sinceIso,
+      run,
+      worktree,
+      receipt,
+      artifacts,
+      artifacts_more: Math.max(0, files.length - MAX_ARTIFACTS),
+      number: number ? number.value : null,
+      number_text: number ? number.text : null,
+    },
+  };
+}
+
+function printHuman(value) {
+  const { run } = value;
+  console.log('');
+  if (run) {
+    const model = run.model ? ` (${run.model})` : '';
+    const took = run.seconds === null ? '' : `, ${Math.round(run.seconds)}s`;
+    console.log(`${value.member}: last run ${run.status}, started ${run.started}${took}, on ${run.engine}${model}`);
+    if (run.id) console.log(`  run: ${run.id}`);
+  } else {
+    console.log(`${value.member}: no run on record in the last ${RUN_DAYS} days`);
+  }
+  if (value.worktree) console.log(`  worked in: ${value.worktree}`);
+  console.log(`  since: ${value.since || 'any time'}`);
+  if (value.receipt) {
+    console.log(`\nreceipt: ${value.receipt.path}`);
+    const lines = String(value.receipt.head || '').split('\n').slice(0, 12);
+    for (const line of lines) console.log(`  ${line}`);
+  } else {
+    console.log('\nreceipt: none written since then');
+  }
+  console.log(`\nartifacts: ${value.artifacts.length}${value.artifacts_more ? ` (+${value.artifacts_more} more)` : ''}`);
+  for (const file of value.artifacts) console.log(`  ${file.path} (${file.size} bytes)`);
+  console.log(`\nnumber: ${value.number_text || 'none stated plainly'}\n`);
+}
+
+function memberResultCommand(args = [], deps = {}) {
+  const root = deps.root || process.cwd();
+  let parsed;
+  try {
+    parsed = parseResultArgs(args);
+  } catch (error) {
+    console.error(`member result: ${error.message}`);
+    return 2;
+  }
+  if (parsed.help) {
+    console.log(usage());
+    return 0;
+  }
+  const result = memberResult(root, parsed.member, { since: parsed.since, now: deps.now, deps });
+  if (!result.ok) {
+    if (parsed.json) console.log(JSON.stringify({ ok: false, error: result.error }, null, 2));
+    else console.error(`member result: ${result.error}`);
+    return 1;
+  }
+  if (parsed.json) console.log(JSON.stringify(result.value, null, 2));
+  else printHuman(result.value);
+  return 0;
+}
+
+module.exports = {
+  memberResult,
+  memberResultCommand,
+  obviousNumber,
+  parseResultArgs,
+};

package/lib/roster-models.js

@@ -124,7 +124,7 @@ function runsDetail(view) {
 // keeps a cache of the models it can run; claude takes the names atris knows;
 // every other engine lists its seed models.
 
-const KNOWN_CLAUDE_MODELS = Object.freeze(['opus 5.5', 'opus 5', 'sonnet 5', 'haiku 4.5', 'fable 5.1']);
+const KNOWN_CLAUDE_MODELS = Object.freeze(['opus 5.5', 'opus 5', 'sonnet 5', 'haiku 5.5', 'fable 5.1']);
 
 // ~/.codex/models_cache.json unless a path is given. Test runs never read the
 // real file unless they point at one on purpose.

package/lib/runner-command.js

@@ -71,7 +71,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
   }),
   haiku: Object.freeze({
     bin: 'claude',
-    model: 'claude-haiku-4-5',
+    model: 'claude-haiku-5-5',
     commandTemplate: '',
     effortFlag: '--effort',
     efforts: CLAUDE_EFFORTS,
@@ -230,12 +230,12 @@ function ownModelsOnlyEngineForBin(bin) {
 // vendor's models drops a claude model name (a mission's stored default, a
 // claude env pin) and rides its own default instead.
 function runnerModelFor(engineId, model) {
-  const value = String(model || '').trim();
+  // Required here, not at the top: engine-registry requires this file.
+  const { isClaudeFamilyModel, currentClaudeModel } = require('./engine-registry');
+  const value = currentClaudeModel(String(model || '').trim());
   const name = String(engineId || '').trim().toLowerCase();
   const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[name] || name];
   if (!value || !def || !def.ownModelsOnly) return value;
-  // Required here, not at the top: engine-registry requires this file.
-  const { isClaudeFamilyModel } = require('./engine-registry');
   return isClaudeFamilyModel(value) ? '' : value;
 }
 

package/lib/task-list-keeper.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const taskDb = require('./task-db');
+const { protectedLaneOf } = require('./auto-accept-certified');
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 const OPEN_STATUSES = new Set(['open', 'claimed', 'review']);
@@ -57,12 +58,28 @@ function actorName(actor) {
   return actor || process.env.ATRIS_AGENT_ID || process.env.USER || 'task-list';
 }
 
-function decisionFor(row, now) {
+function parsedMetadata(row) {
+  let metadata = row && row.metadata;
+  if (typeof metadata === 'string') {
+    try { metadata = JSON.parse(metadata); } catch { metadata = null; }
+  }
+  return metadata && typeof metadata === 'object' ? metadata : {};
+}
+
+// Money, deploys, security, customer, and outward work is the human's call.
+// Sitting still is not a decision, so idle time never puts it away.
+function isProtectedRow(row) {
+  return Boolean(protectedLaneOf({ ...row, metadata: parsedMetadata(row) }));
+}
+
+function decisionFor(row, now, { includeDone = true } = {}) {
   if (!row || row.status === 'archived') return null;
   if (row.status === 'done') {
+    if (!includeDone) return null;
     return { reason: REASONS.done, fromDone: true, fromFailed: false };
   }
   if (!Object.prototype.hasOwnProperty.call(IDLE_LIMITS_MS, row.status)) return null;
+  if (OPEN_STATUSES.has(row.status) && isProtectedRow(row)) return null;
   const at = Number(row.updated_at || row.created_at || 0);
   if (!((now - at) > IDLE_LIMITS_MS[row.status])) return null;
   return { reason: REASONS[row.status], fromDone: false, fromFailed: row.status === 'failed' };
@@ -112,7 +129,10 @@ function noteKeep(workspaceRoot, actor, count) {
   }
 }
 
-function keepTaskList(db, { workspaceRoot, actor, now = Date.now(), missions } = {}) {
+// includeDone:false leaves finished rows on the list: the hourly tick must
+// not hide work it just landed from the digest and mission checks that read
+// done rows later in the same tick. Boot and `task keep` still put them away.
+function keepTaskList(db, { workspaceRoot, actor, now = Date.now(), missions, includeDone = true } = {}) {
   const who = actorName(actor);
   const seen = new Set();
   const toArchive = [];
@@ -120,7 +140,7 @@ function keepTaskList(db, { workspaceRoot, actor, now = Date.now(), missions } =
   for (const row of selectCandidates(db, workspaceRoot, now)) {
     if (!row || seen.has(row.id)) continue;
     seen.add(row.id);
-    const decision = decisionFor(row, now);
+    const decision = decisionFor(row, now, { includeDone });
     if (decision) {
       toArchive.push({ id: row.id, previous_status: row.status, ...decision });
       continue;
@@ -171,7 +191,7 @@ function keepTaskList(db, { workspaceRoot, actor, now = Date.now(), missions } =
   return { put_away: putAway, reaped };
 }
 
-function keepWorkspaceTaskList(cwd = process.cwd(), { actor } = {}) {
+function keepWorkspaceTaskList(cwd = process.cwd(), { actor, includeDone = true } = {}) {
   const dbPath = taskDb.getDbPath();
   if (!dbPath || !fs.existsSync(dbPath)) {
     return { put_away: [], reaped: [], skipped: 'no_db' };
@@ -181,6 +201,7 @@ function keepWorkspaceTaskList(cwd = process.cwd(), { actor } = {}) {
     workspaceRoot: taskDb.workspaceRoot(cwd),
     actor,
     now: Date.now(),
+    includeDone,
   });
 }
 

package/lib/trust-tiers.js

@@ -7,6 +7,10 @@ const HISTORY_FILES = [
   path.join('.atris', 'state', 'career_xp_receipts.jsonl'),
   path.join('.atris', 'state', 'scorecards.jsonl'),
 ];
+// Where a legacy history row's builder is recovered from: the row only names
+// its task, and these name who built that task.
+const EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
+const PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
 
 const PASS_OUTCOMES = new Set(['accepted', 'approved', 'done', 'pass', 'passed', 'success', 'succeeded']);
 const FAIL_OUTCOMES = new Set(['bounced', 'fail', 'failed', 'rejected', 'revised', 'rework_requested']);
@@ -15,17 +19,34 @@ function normalizedActor(value) {
   return String(value || '').trim().toLowerCase();
 }
 
-function rowActor(row) {
-  return normalizedActor(row?.claimed_by || row?.metadata?.executed_by);
+// Trust belongs to whoever BUILT the work, never to whoever approved it.
+// History rows record `actor` as the approving reviewer (one human on 1,029
+// of 1,057 receipts in one busy project), so keying on it, or on fields the
+// rows never carried, left every builder at zero history and "still earning
+// trust" forever. `actor` is deliberately not read here.
+function stampedBuilder(row) {
+  return normalizedActor(
+    row?.builder
+    || row?.built_by
+    || row?.claimed_by
+    || row?.metadata?.built_by
+    || row?.metadata?.executed_by,
+  );
+}
+
+function rowTaskId(row) {
+  return String(row?.source_task_id || row?.task_id || '').trim();
 }
 
 function rowPassed(row) {
   for (const value of [row?.passed, row?.verify_passed, row?.metadata?.verify_passed]) {
     if (typeof value === 'boolean') return value;
   }
-  const outcome = String(row?.outcome || row?.status || '').trim().toLowerCase();
-  if (PASS_OUTCOMES.has(outcome)) return true;
-  if (FAIL_OUTCOMES.has(outcome)) return false;
+  for (const value of [row?.outcome, row?.status, row?.rl_label]) {
+    const outcome = String(value || '').trim().toLowerCase();
+    if (PASS_OUTCOMES.has(outcome)) return true;
+    if (FAIL_OUTCOMES.has(outcome)) return false;
+  }
   return null;
 }
 
@@ -37,6 +58,53 @@ function rowTime(row) {
   return null;
 }
 
+function fileStamp(file) {
+  try {
+    const stat = fs.statSync(file);
+    return `${stat.size}:${stat.mtimeMs}`;
+  } catch {
+    return 'missing';
+  }
+}
+
+function eachJsonLine(file, fn) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line);
+      if (row && typeof row === 'object' && !Array.isArray(row)) fn(row);
+    } catch {
+      // A torn line in the episode log only costs that one lookup.
+    }
+  }
+}
+
+// task id -> builder, from the episode log (every review snapshot carries the
+// task's built_by / claimed_by) and the live projection.
+function readTaskBuilders(root) {
+  const builders = new Map();
+  const remember = (taskId, task) => {
+    const id = String(taskId || '').trim();
+    const builder = normalizedActor(task?.metadata?.built_by || task?.claimed_by);
+    if (id && builder) builders.set(id, builder);
+  };
+  eachJsonLine(path.join(root, EPISODES_FILE), (episode) => remember(episode.task_id, episode.state));
+  try {
+    const projection = JSON.parse(fs.readFileSync(path.join(root, PROJECTION_FILE), 'utf8'));
+    const tasks = Array.isArray(projection) ? projection : projection?.tasks;
+    for (const task of Array.isArray(tasks) ? tasks : []) remember(task?.id, task);
+  } catch {
+    // No projection: episode builders still apply.
+  }
+  return builders;
+}
+
 function readHistory(root) {
   const rows = [];
   let sequence = 0;
@@ -62,16 +130,58 @@ function readHistory(root) {
   return rows;
 }
 
-function computeTrustTier(actor, root = process.cwd()) {
-  const target = normalizedActor(actor);
-  if (!target) return 'probation';
+// One outcome per review episode: a receipt and a scorecard written for the
+// same episode are the same verdict, not two.
+function builderOutcomes(root) {
   const history = readHistory(root);
-  if (!history) return 'probation';
+  if (!history) return null;
+  let builders = null;
+  const byBuilder = new Map();
+  const seenEpisodes = new Set();
+  for (const entry of history) {
+    const passed = rowPassed(entry.row);
+    if (passed === null) continue;
+    const episode = String(entry.row.source_episode_id || '').trim();
+    if (episode) {
+      if (seenEpisodes.has(episode)) continue;
+      seenEpisodes.add(episode);
+    }
+    let builder = stampedBuilder(entry.row);
+    if (!builder && rowTaskId(entry.row)) {
+      if (!builders) builders = readTaskBuilders(root);
+      builder = builders.get(rowTaskId(entry.row)) || '';
+    }
+    if (!builder) continue;
+    if (!byBuilder.has(builder)) byBuilder.set(builder, []);
+    byBuilder.get(builder).push({ ...entry, passed });
+  }
+  return byBuilder;
+}
 
-  const outcomes = history
-    .filter(({ row }) => rowActor(row) === target)
-    .map((entry) => ({ ...entry, passed: rowPassed(entry.row) }))
-    .filter(({ passed }) => passed !== null)
+// Called once per waiting task on every status and tick, against a 12 MB
+// episode log; memoize per root until one of the files changes.
+const outcomeCache = new Map();
+
+function cachedBuilderOutcomes(root) {
+  const resolved = path.resolve(root);
+  const stamp = [...HISTORY_FILES, EPISODES_FILE, PROJECTION_FILE]
+    .map((relative) => fileStamp(path.join(resolved, relative)))
+    .join('|');
+  const hit = outcomeCache.get(resolved);
+  if (hit && hit.stamp === stamp) return hit.value;
+  const value = builderOutcomes(resolved);
+  outcomeCache.set(resolved, { stamp, value });
+  return value;
+}
+
+function computeTrustTier(builder, root = process.cwd()) {
+  const target = normalizedActor(builder);
+  if (!target) return 'probation';
+  const byBuilder = cachedBuilderOutcomes(root);
+  if (!byBuilder) return 'probation';
+
+  const outcomes = (byBuilder.get(target) || [])
+    .slice()
     .sort((a, b) => {
       if (a.time !== null && b.time !== null && a.time !== b.time) return a.time - b.time;
       if (a.time !== null && b.time === null) return 1;
@@ -87,4 +197,11 @@ function computeTrustTier(actor, root = process.cwd()) {
   return 'probation';
 }
 
-module.exports = { computeTrustTier };
+// The builder of a task: the stamped builder first, then whoever claimed it.
+// Never the approver.
+function taskTrustSubject(task) {
+  const metadata = task?.metadata || {};
+  return normalizedActor(metadata.built_by || task?.claimed_by || metadata.executed_by) || null;
+}
+
+module.exports = { computeTrustTier, taskTrustSubject };