atris 3.64.0 → 3.66.0

package/lib/team-lineup.js

@@ -4,7 +4,7 @@
 // come from the same resolver `atris engine roster` uses (jobRosterView and
 // rosterReport in commands/engine.js); this file only picks and words them.
 
-const { engineRunsView, modelLabel } = require('./roster-models');
+const { modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
 const { suggestionCount } = require('./roster-suggest');
 
@@ -75,75 +75,6 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   return `${builtIn.join(' · ')}${marker}`;
 }
 
-function runsText(view) {
-  return view && view.text ? view.text : 'no ready tool';
-}
-
-// "who does each job" lines: the tool and model running each job now, its
-// backup, and a short note when the router or a backup is standing in.
-function renderJobLines(jobs, { width = 80 } = {}) {
-  const rows = orderJobs(jobs);
-  if (!rows.length) return [];
-  const labelWidth = Math.max(...rows.map((row) => row.job.length));
-  return rows.map((row) => {
-    const head = `  ${row.job.padEnd(labelWidth)}  ${runsText(row.now_runs)}`;
-    let note = '';
-    if (!row.pick) note = row.like ? `, same as ${row.like}` : ', picked by the router';
-    else if (row.lead === 'first' && row.backup_runs) note = `, backup ${row.backup_runs.text}`;
-    else if (row.lead !== 'first') note = row.status === 'expired' ? ', first pick expired' : ', first pick not ready';
-    const line = `${head}${note}`;
-    return line.length <= width || row.lead !== 'first' ? line : head;
-  });
-}
-
-// Names under each job, wrapped to the width. A member running something
-// other than its job's tool and model says what it runs.
-function renderMemberLines(team, jobs, { width = 80 } = {}) {
-  const members = Array.isArray(team) ? team : [];
-  if (!members.length) return [];
-  const rows = orderJobs(jobs);
-  const order = [...rows.map((row) => row.job)];
-  for (const member of members) if (member.job && !order.includes(member.job)) order.push(member.job);
-  const groups = order
-    .map((job) => ({ job, row: rows.find((row) => row.job === job) || null, names: members.filter((member) => member.job === job) }))
-    .filter((group) => group.names.length);
-  const labelWidth = Math.max(...groups.map((group) => group.job.length));
-  const indent = ' '.repeat(labelWidth + 4);
-  const lines = [];
-  for (const group of groups) {
-    const jobText = group.row && group.row.now_runs ? group.row.now_runs.text : '';
-    const names = group.names.map((member) => {
-      const text = member.engine ? engineRunsView(member.engine, { model: member.model || '', effort: member.effort || '' }).text : 'no ready tool';
-      return text === jobText ? member.member : `${member.member} on ${text}`;
-    });
-    let line = `  ${group.job.padEnd(labelWidth)}  `;
-    let fresh = true;
-    for (const name of names) {
-      const piece = fresh ? name : `, ${name}`;
-      if (!fresh && line.length + piece.length + 1 > width) {
-        lines.push(`${line},`);
-        line = `${indent}${name}`;
-      } else {
-        line += piece;
-      }
-      fresh = false;
-    }
-    lines.push(line);
-  }
-  return lines;
-}
-
-// The block `atris team` prints before today's active and rest lists.
-function renderLineup(lineup, { width = 80 } = {}) {
-  if (!lineup || !lineup.ok) return '';
-  const jobLines = renderJobLines(lineup.jobs, { width });
-  const memberLines = renderMemberLines(lineup.team, lineup.jobs, { width });
-  const blocks = [];
-  if (jobLines.length) blocks.push(['who does each job:', ...jobLines].join('\n'));
-  if (memberLines.length) blocks.push(['who is on each job:', ...memberLines].join('\n'));
-  return blocks.join('\n\n');
-}
-
 // Per member, for json: the job, tool, model, and whether a roster line or
 // the automatic match decided it. null for a name the lineup does not know.
 function memberLineup(lineup, name) {
@@ -161,12 +92,20 @@ function memberLineup(lineup, name) {
   };
 }
 
+// The two commands under both team tables: the real way to change a job's
+// worker (assign takes a job, not a member) and the real way to start a
+// member working (it runs on the member's roster engine).
+const TEAM_FOOTER = Object.freeze([
+  'change who does a job: atris engine assign <job> <tool> --model <model>',
+  'launch a member: atris member run <member> "<goal>" --minutes 30',
+]);
+
 const LINEUP_UNREADABLE = 'could not read who does each job, so tools and models are not shown. try: atris engine roster';
 
 module.exports = {
   LINEUP_UNREADABLE,
+  TEAM_FOOTER,
   bootTeamLine,
   memberLineup,
   readLineupSafe,
-  renderLineup,
 };

package/lib/team-presence.js

@@ -262,10 +262,234 @@ function renderTeamPresence(presence) {
   return lines.join('\n');
 }
 
+// --- who really worked this week ------------------------------------------
+//
+// "Awake" above is a 15-minute window. A member that did real work yesterday
+// is not awake, but it is active. Activity reads evidence that already sits
+// on disk: dated files in atris/team/<member>/logs/, commits that name the
+// member, runs the roster recorded for the member, and the same stream
+// events presence reads (task claims, mission receipts, worktree commits),
+// over a wider window. Each piece of evidence counts as one run on its day.
+// A member with evidence in the last 7 days is active; 8 to 14 days is
+// quiet; nothing in 14 days is idle.
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const ACTIVE_DAYS = 7;
+const IDLE_AFTER_DAYS = 14;
+const FAILED_RUN_OUTCOMES = new Set(['failed', 'stalled', 'credit out']);
+
+function localDay(ms) {
+  const date = new Date(ms);
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+// The first real YYYY-MM-DD in a log file name, as a local day ('' if none).
+function logFileDay(name) {
+  const match = /(\d{4})-(\d{2})-(\d{2})/.exec(String(name || ''));
+  if (!match) return '';
+  const [year, month, day] = match.slice(1).map(Number);
+  const date = new Date(year, month - 1, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) return '';
+  return match[0];
+}
+
+// `git log --format=%x1e%aI%x1f%B` output, read once for the whole team.
+function parseGitLog(text) {
+  return String(text || '').split('\x1e').map((chunk) => {
+    const [at, ...rest] = chunk.split('\x1f');
+    const message = rest.join('\x1f').trim();
+    const ms = timestampMs(String(at || '').trim());
+    if (!ms || !message) return null;
+    const [subject, ...body] = message.split(/\r?\n/);
+    return { ms, subject: subject.trim(), body: body.join('\n') };
+  }).filter(Boolean);
+}
+
+// Which members a commit names, and whether it is a revert. Plain words are
+// not enough: member names like "notes", "sites", and "builder" also show up
+// in ordinary messages and in the atris-builder co-author line. A commit
+// names a member through a "Member: <name>" or "Atris-Member: <name>"
+// trailer, a co-author whose display name is the member, or a subject that
+// starts with "<name>:" or "<name>(scope):". A revert names whoever the
+// reverted subject named.
+function commitMembers(commit, known) {
+  const names = new Set();
+  const check = (value) => {
+    const key = String(value || '').trim().toLowerCase();
+    if (key && known.has(key)) names.add(key);
+  };
+  let subject = String(commit.subject || '');
+  const revert = /^revert\s+"(.+)"\s*$/i.exec(subject);
+  if (revert) subject = revert[1];
+  const prefix = /^([a-z0-9][a-z0-9_.-]*)(?:\([^)]*\))?:\s/i.exec(subject);
+  if (prefix) check(prefix[1]);
+  for (const line of String(commit.body || '').split(/\r?\n/)) {
+    const trailer = /^\s*(?:atris-)?member:\s*([a-z0-9_.-]+)\s*$/i.exec(line);
+    if (trailer) check(trailer[1]);
+    const coauthor = /^\s*co-authored-by:\s*([^<]+?)\s*</i.exec(line);
+    if (coauthor) check(coauthor[1]);
+  }
+  return { names: [...names], reverted: Boolean(revert) };
+}
+
+function emptyDay() {
+  return { runs: 0, landed: 0, failed: 0, reverted: 0, engines: {}, models: {} };
+}
+
+function topKey(counts) {
+  let best = '';
+  for (const [key, count] of Object.entries(counts || {})) {
+    if (!best || count > counts[best]) best = key;
+  }
+  return best || null;
+}
+
+// The busiest engine and the busiest model among that engine's own runs, so
+// the pair always names something that actually ran together.
+function enginePair(engines, models) {
+  const engine = topKey(engines);
+  const own = Object.fromEntries(Object.entries(models || {}).filter(([key]) => !engine || key.startsWith(`${engine}\u0000`)));
+  const modelKey = topKey(own);
+  return { engine, model: modelKey ? modelKey.split('\u0000')[1] : null };
+}
+
+// One activity row per member, from evidence gathered by the caller:
+//   logDays: { member: ['2026-09-28', ...] }
+//   commits: parsed git log rows ({ ms, subject, body })
+//   runs:    roster run records ({ at, member, engine, model, outcome })
+//   events:  stream events ({ agent, ms | ts, summary })
+function buildMemberActivity(input = {}) {
+  const nowMs = timestampMs(input.nowMs ?? input.now ?? Date.now()) || Date.now();
+  const names = [...new Set((input.members || []).map((name) => String(name || '').trim().toLowerCase()).filter(Boolean))];
+  const known = new Set(names);
+  const today = localDay(nowMs);
+  const activeSince = localDay(nowMs - (ACTIVE_DAYS - 1) * DAY_MS);
+  const quietSince = localDay(nowMs - (IDLE_AFTER_DAYS - 1) * DAY_MS);
+  const byMember = new Map(names.map((name) => [name, { days: {}, last: '', evidence: { logs: 0, commits: 0, runs: 0, events: 0 } }]));
+  const note = (member, day, source, apply) => {
+    const row = byMember.get(member);
+    if (!row || !day || day > today) return;
+    if (day > row.last) row.last = day;
+    if (day < quietSince) return;
+    const bucket = row.days[day] || (row.days[day] = emptyDay());
+    bucket.runs += 1;
+    row.evidence[source] += 1;
+    if (apply) apply(bucket);
+  };
+
+  for (const [member, days] of Object.entries(input.logDays || {})) {
+    for (const day of days || []) note(String(member).toLowerCase(), logFileDay(day), 'logs');
+  }
+  for (const commit of input.commits || []) {
+    const { names: named, reverted } = commitMembers(commit, known);
+    for (const member of named) {
+      note(member, localDay(commit.ms), 'commits', (bucket) => {
+        if (reverted) bucket.reverted += 1;
+        else bucket.landed += 1;
+      });
+    }
+  }
+  for (const run of input.runs || []) {
+    const member = String(run.member || '').trim().toLowerCase();
+    const ms = timestampMs(run.at);
+    if (!member || !ms) continue;
+    note(member, localDay(ms), 'runs', (bucket) => {
+      if (run.outcome === 'landed') bucket.landed += 1;
+      else if (FAILED_RUN_OUTCOMES.has(run.outcome)) bucket.failed += 1;
+      if (run.engine) bucket.engines[run.engine] = (bucket.engines[run.engine] || 0) + 1;
+      if (run.model) bucket.models[`${run.engine || ''}\u0000${run.model}`] = (bucket.models[`${run.engine || ''}\u0000${run.model}`] || 0) + 1;
+    });
+  }
+  // A task or mission shows up as several stream events; one per summary
+  // per day counts.
+  const seenEvents = new Set();
+  for (const event of input.events || []) {
+    const member = memberName(event?.agent || event?.member || event?.owner).toLowerCase();
+    const ms = timestampMs(event?.ms || event?.ts || event?.at || event?.created_at);
+    if (!member || !ms || !known.has(member)) continue;
+    const day = localDay(ms);
+    const key = `${member}|${day}|${event.summary || event.event || ''}`;
+    if (seenEvents.has(key)) continue;
+    seenEvents.add(key);
+    note(member, day, 'events');
+  }
+
+  return names.map((name) => {
+    const row = byMember.get(name);
+    const week = Object.entries(row.days).filter(([day]) => day >= activeSince);
+    const sum = (field) => week.reduce((total, [, bucket]) => total + bucket[field], 0);
+    const engines = {};
+    const models = {};
+    for (const [, bucket] of week) {
+      for (const [key, count] of Object.entries(bucket.engines)) engines[key] = (engines[key] || 0) + count;
+      for (const [key, count] of Object.entries(bucket.models)) models[key] = (models[key] || 0) + count;
+    }
+    const { engine, model } = enginePair(engines, models);
+    const lastMs = row.last ? new Date(`${row.last}T12:00:00`).getTime() : 0;
+    const status = row.last >= activeSince ? 'active' : row.last >= quietSince ? 'quiet' : 'idle';
+    return {
+      name,
+      status,
+      last_active: row.last || null,
+      days_since: row.last ? Math.max(0, Math.round((new Date(`${today}T12:00:00`).getTime() - lastMs) / DAY_MS)) : null,
+      runs_7d: sum('runs'),
+      engine,
+      model,
+      landed: sum('landed'),
+      failed: sum('failed'),
+      reverted: sum('reverted'),
+      evidence: row.evidence,
+      days: Object.fromEntries(Object.entries(row.days).sort(([a], [b]) => a.localeCompare(b)).map(([day, bucket]) => [day, {
+        runs: bucket.runs,
+        ...enginePair(bucket.engines, bucket.models),
+        landed: bucket.landed,
+        failed: bucket.failed,
+        reverted: bucket.reverted,
+      }])),
+    };
+  });
+}
+
+// The first local day of the 7-day activity window.
+function activeWindowStartDay(nowMs = Date.now()) {
+  return localDay((timestampMs(nowMs) || Date.now()) - (ACTIVE_DAYS - 1) * DAY_MS);
+}
+
+// One row per member per day with any evidence in the last 7 days, the
+// shape the self-improvement loop reads from member_activity.jsonl.
+function memberActivityRows(activity, nowMs = Date.now()) {
+  const since = activeWindowStartDay(nowMs);
+  const rows = [];
+  for (const member of activity || []) {
+    for (const [day, bucket] of Object.entries(member.days || {})) {
+      if (day < since || !bucket.runs) continue;
+      rows.push({
+        member: member.name,
+        day,
+        runs: bucket.runs,
+        engine: bucket.engine,
+        model: bucket.model,
+        landed: bucket.landed,
+        failed: bucket.failed,
+        reverted: bucket.reverted,
+      });
+    }
+  }
+  return rows.sort((a, b) => a.day.localeCompare(b.day) || a.member.localeCompare(b.member));
+}
+
 module.exports = {
   ACTIVE_MISSION_STATES,
   ACTIVE_TASK_STATES,
   DEFAULT_FRESHNESS_WINDOW_MS,
+  IDLE_AFTER_DAYS,
+  activeWindowStartDay,
+  buildMemberActivity,
   buildTeamPresence,
+  commitMembers,
+  logFileDay,
+  memberActivityRows,
+  parseGitLog,
   renderTeamPresence,
 };

package/lib/text-table.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Plain aligned tables for terminal views: a header row, two spaces between
+// columns, no borders or pipes. A cell may hold several lines; the extra
+// lines sit under the first, in the same column. When the table is wider
+// than the terminal, columns marked `clip` or `wrap` shrink (rightmost
+// first): a clip column ends in "…", a wrap column carries on underneath.
+// Every other column keeps its full width.
+
+const GAP = '  ';
+const ELLIPSIS = '…';
+const FALLBACK_WIDTH = 100;
+
+function terminalWidth(width) {
+  const value = Number(width || process.stdout.columns);
+  return Number.isFinite(value) && value >= 20 ? value : FALLBACK_WIDTH;
+}
+
+function clipText(text, width) {
+  const value = String(text);
+  if (value.length <= width) return value;
+  if (width <= 1) return ELLIPSIS.slice(0, Math.max(0, width));
+  return `${value.slice(0, width - 1).trimEnd()}${ELLIPSIS}`;
+}
+
+// Word-wrap one line to a width; a word longer than the width is split.
+function wrapText(text, width) {
+  const out = [];
+  let line = '';
+  for (let word of String(text).split(' ')) {
+    while (word.length > width) {
+      if (line) { out.push(line); line = ''; }
+      out.push(word.slice(0, width));
+      word = word.slice(width);
+    }
+    const next = line ? `${line} ${word}` : word;
+    if (next.length > width && line) { out.push(line); line = word; } else line = next;
+  }
+  out.push(line);
+  return out;
+}
+
+function cellLines(value) {
+  if (Array.isArray(value)) {
+    const lines = value.filter((line) => line !== null && line !== undefined).map(String);
+    return lines.length ? lines : [''];
+  }
+  return [value === null || value === undefined ? '' : String(value)];
+}
+
+// columns: [{ header, clip?, min? }]; rows: arrays of cells, one per column.
+// Returns the table as one string, each line trimmed at the end.
+function renderTable(columns, rows, { width } = {}) {
+  const max = terminalWidth(width);
+  const cells = rows.map((row) => columns.map((_, index) => cellLines(row[index])));
+  const widths = columns.map((column, index) => Math.max(
+    String(column.header).length,
+    ...cells.map((row) => Math.max(...row[index].map((line) => line.length))),
+  ));
+  let over = widths.reduce((sum, value) => sum + value, 0) + GAP.length * (columns.length - 1) - max;
+  for (let index = columns.length - 1; index >= 0 && over > 0; index -= 1) {
+    if (!columns[index].clip && !columns[index].wrap) continue;
+    const floor = Math.max(String(columns[index].header).length, columns[index].min || 8);
+    const cut = Math.min(over, Math.max(0, widths[index] - floor));
+    widths[index] -= cut;
+    over -= cut;
+  }
+  const line = (parts) => parts
+    .map((text, index) => clipText(text, widths[index]).padEnd(index === parts.length - 1 ? 0 : widths[index]))
+    .join(GAP)
+    .trimEnd();
+  const out = [line(columns.map((column) => column.header))];
+  for (const raw of cells) {
+    const row = raw.map((lines, index) => (columns[index].wrap ? lines.flatMap((text) => wrapText(text, widths[index])) : lines));
+    const height = Math.max(...row.map((lines) => lines.length));
+    for (let at = 0; at < height; at += 1) out.push(line(row.map((lines) => lines[at] || '')));
+  }
+  return out.join('\n');
+}
+
+module.exports = { FALLBACK_WIDTH, clipText, renderTable, terminalWidth };

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 };