atris 3.61.0 → 3.63.0

package/commands/land.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { runGit } = require('../lib/git-spawn');
+const gitSpawn = require('../lib/git-spawn');
 const { compactErrorPayload, printCliJson } = require('../lib/cli-json');
 const { listWorktrees, statusCounts } = require('./worktree');
 
@@ -9,6 +9,14 @@ const DEFAULT_STALE_HOURS = 48;
 const WORKTREE_REAP_GRACE_MS = 60 * 60 * 1000;
 const PROTECTED_BRANCHES = new Set(['main', 'master']);
 
+// Through the module object so tests can count git spawns with a spy.
+function runGit(args, opts) {
+  return gitSpawn.runGit(args, opts);
+}
+
+const CHERRY_CACHE_FILE = path.join('.atris', 'state', 'cherry-cache.json');
+const CHERRY_CACHE_MAX = 2000;
+
 // Pluralize a count + noun ("1 change", "2 changes").
 function countLabel(n, word) {
   return `${n} ${word}${n === 1 ? '' : 's'}`;
@@ -157,10 +165,11 @@ function checkoutKeepLine(name, bound, now) {
 function listBranches(root, base = '') {
   // With a base, ask git for ahead counts in the same single spawn
   // (%(ahead-behind:) needs git >= 2.41; on failure we retry without it and
-  // collectBoard falls back to per-branch aheadCount).
+  // collectBoard falls back to per-branch aheadCount). The branch sha comes
+  // along in the same spawn so the cherry cache needs no per-branch lookup.
   const format = base
-    ? `%(refname:short)%09%(committerdate:unix)%09%(ahead-behind:${base})`
-    : '%(refname:short)%09%(committerdate:unix)';
+    ? `%(refname:short)%09%(committerdate:unix)%09%(objectname)%09%(ahead-behind:${base})`
+    : '%(refname:short)%09%(committerdate:unix)%09%(objectname)';
   const result = runGit(['for-each-ref', 'refs/heads', `--format=${format}`], { cwd: root, check: false });
   if (result.status !== 0) {
     if (base) return listBranches(root);
@@ -170,8 +179,9 @@ function listBranches(root, base = '') {
     .split(/\r?\n/)
     .filter(Boolean)
     .map((line) => {
-      const [name, date, aheadBehind] = line.split('\t');
+      const [name, date, sha, aheadBehind] = line.split('\t');
       const entry = { name, lastCommitUnix: Number(date) };
+      if (sha) entry.sha = sha;
       if (aheadBehind !== undefined) {
         const ahead = Number(aheadBehind.split(' ')[0]);
         if (Number.isFinite(ahead)) entry.ahead = ahead;
@@ -206,6 +216,82 @@ function cherryStats(root, base, ref) {
   return { landedElsewhere, unique };
 }
 
+// `git cherry <base> <ref>` depends only on the two commit shas, so its
+// counts are cached per (base sha, ref sha) under .atris/state. The cache is
+// only written where .atris already exists; a missing or corrupt file means
+// recompute. Entries for refs not seen this run are dropped on save.
+function cherryCachePath(root) {
+  return path.join(root, CHERRY_CACHE_FILE);
+}
+
+function loadCherryCache(root) {
+  const cache = { file: cherryCachePath(root), entries: {}, used: {}, dirty: false, writable: false };
+  try {
+    cache.writable = fs.statSync(path.join(root, '.atris')).isDirectory();
+  } catch {
+    cache.writable = false;
+  }
+  if (!cache.writable) return cache;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cache.file, 'utf8'));
+    if (parsed && parsed.version === 1 && parsed.entries && typeof parsed.entries === 'object') {
+      cache.entries = parsed.entries;
+    }
+  } catch {
+    cache.entries = {};
+  }
+  return cache;
+}
+
+function validCherryEntry(entry) {
+  return entry && Number.isInteger(entry.landedElsewhere) && Number.isInteger(entry.unique)
+    && entry.landedElsewhere >= 0 && entry.unique >= 0;
+}
+
+function cachedCherryStats(cache, cwd, base, baseSha, ref, refSha) {
+  if (!cache || !baseSha || !refSha) return cherryStats(cwd, base, ref);
+  const key = `${baseSha}:${refSha}`;
+  const hit = cache.entries[key];
+  if (validCherryEntry(hit)) {
+    cache.used[key] = hit;
+    return { landedElsewhere: hit.landedElsewhere, unique: hit.unique };
+  }
+  // Cherry the exact commits the key names, so a ref that moves mid-run
+  // can never file one pair's result under another pair's key.
+  const result = runGit(['cherry', baseSha, refSha], { cwd, check: false });
+  if (result.status !== 0) return { landedElsewhere: 0, unique: 0 };
+  const stats = { landedElsewhere: 0, unique: 0 };
+  for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
+    if (line.startsWith('- ')) stats.landedElsewhere += 1;
+    else if (line.startsWith('+ ')) stats.unique += 1;
+  }
+  cache.used[key] = { ...stats };
+  cache.dirty = true;
+  return stats;
+}
+
+function saveCherryCache(cache) {
+  if (!cache || !cache.writable) return;
+  const usedKeys = Object.keys(cache.used);
+  // Rewrite when something new was computed or something stale can go.
+  if (!cache.dirty && usedKeys.length === Object.keys(cache.entries).length) return;
+  const entries = {};
+  for (const key of usedKeys.slice(-CHERRY_CACHE_MAX)) entries[key] = cache.used[key];
+  try {
+    fs.mkdirSync(path.dirname(cache.file), { recursive: true });
+    const tmp = `${cache.file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify({ version: 1, entries })}\n`);
+    fs.renameSync(tmp, cache.file);
+  } catch {
+    // The cache is only a speedup; a failed write costs a recompute next time.
+  }
+}
+
+function resolveSha(root, ref) {
+  const result = runGit(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], { cwd: root, check: false });
+  return result.status === 0 ? result.stdout.trim() : '';
+}
+
 // Board: every branch and worktree with unlanded state, classified.
 //   landed, no commits ahead of base; the branch pointer is residue
 //   active, has unlanded commits, younger than TTL
@@ -220,6 +306,8 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
 
   const branches = [];
   const lastCommitMsByBranch = new Map();
+  const cherryCache = loadCherryCache(root);
+  const baseSha = resolveSha(root, base);
   for (const branch of listBranches(root, base)) {
     if (PROTECTED_BRANCHES.has(branch.name)) continue;
     const lastCommitMs = Number(branch.lastCommitUnix) * 1000;
@@ -227,7 +315,9 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
     const ahead = branch.ahead !== undefined ? branch.ahead : aheadCount(root, base, branch.name);
     const age = ageDays(branch.lastCommitUnix, now);
     const hours = ageHours(branch.lastCommitUnix, now);
-    const cherry = ahead > 0 ? cherryStats(root, base, branch.name) : { landedElsewhere: 0, unique: 0 };
+    const cherry = ahead > 0
+      ? cachedCherryStats(cherryCache, root, base, baseSha, branch.name, branch.sha)
+      : { landedElsewhere: 0, unique: 0 };
     let state = 'active';
     if (ahead === 0 || (cherry.landedElsewhere > 0 && cherry.unique === 0)) state = 'landed';
     else if (age > ttlDays) state = 'due';
@@ -271,7 +361,7 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
       const cnt = runGit(['rev-list', '--count', `${base}..HEAD`], { cwd: wt.path, check: false });
       ahead = cnt.status === 0 ? Number(cnt.stdout.trim()) || 0 : 0;
       if (ahead > 0) {
-        unlandedCommits = cherryStats(wt.path, base, 'HEAD').unique;
+        unlandedCommits = cachedCherryStats(cherryCache, wt.path, base, baseSha, 'HEAD', wt.head).unique;
         const ts = runGit(['log', '-1', '--format=%ct', 'HEAD'], { cwd: wt.path, check: false });
         if (ts.status === 0) ageDaysVal = ageDays(Number(ts.stdout.trim()), now);
         if (!light) subjects = commitSubjects(wt.path, base, 'HEAD');
@@ -309,6 +399,8 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
     branch.stale = branch.state === 'active' && branch.activityHours >= staleHours;
   }
 
+  saveCherryCache(cherryCache);
+
   const due = branches.filter((b) => b.state === 'due');
   const landed = branches.filter((b) => b.state === 'landed');
   const active = branches.filter((b) => b.state === 'active');
@@ -333,6 +425,33 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
   };
 }
 
+// One landing board per process per repo. Boot, stream, and the team view
+// each ask for the board more than once in a single command; the first call
+// pays for git, later calls within BOARD_MEMO_MAX_AGE_MS share the result.
+// A full board also answers light requests (light is a subset). Long-lived
+// callers (stream follow) clear the memo before each poll.
+const BOARD_MEMO_MAX_AGE_MS = 10000;
+const boardMemo = new Map();
+
+function boardMemoKey(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_STALE_HOURS, base = '' } = {}) {
+  return JSON.stringify([canonicalPath(root), ttlDays, staleHours, base]);
+}
+
+function sharedBoard(root, opts = {}) {
+  const key = boardMemoKey(root, opts);
+  const light = Boolean(opts.light);
+  const nowMs = Date.now();
+  const hit = boardMemo.get(key);
+  if (hit && nowMs - hit.at < BOARD_MEMO_MAX_AGE_MS && (light || !hit.light)) return hit.board;
+  const board = collectBoard(root, { ...opts, light });
+  boardMemo.set(key, { board, light, at: Date.now() });
+  return board;
+}
+
+function clearBoardMemo() {
+  boardMemo.clear();
+}
+
 // Counts for the boot banner and digest. This intentionally pays the same
 // classification cost as the landing board so "in the air" never includes
 // merged branch residue.
@@ -340,7 +459,7 @@ function landSummary(cwd = process.cwd(), ttlDays = DEFAULT_TTL_DAYS) {
   const root = repoRoot(cwd);
   if (!root || !hasCommits(root)) return null;
   try {
-    const board = collectBoard(root, { ttlDays, light: true });
+    const board = sharedBoard(root, { ttlDays, light: true });
     return {
       branches: board.summary.active + board.summary.due,
       due: board.summary.due,
@@ -918,9 +1037,11 @@ function landCommand(args = []) {
 }
 
 module.exports = {
+  clearBoardMemo,
   collectBoard,
   countLabel,
   landCommand,
   landSummary,
   reap,
+  sharedBoard,
 };

package/commands/member.js

@@ -7,11 +7,12 @@ const { loadCredentials } = require('../utils/auth');
 const { resolveBackendRoot } = require('../utils/backend-root');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
+const { memberRefusalReason } = require('../lib/member-type');
 const { defaultObjectiveRunner } = require('../lib/default-runner');
 const { readJson, writeJson } = require('../lib/json-file');
 const { sleepSync } = require('../lib/sleep-sync');
 const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
-const { ensureMemberBundle, memberBundlePresent } = require('../lib/member-scaffold');
+const { ensureMemberBundle, memberBundlePresent, updateMemberSkills } = require('../lib/member-scaffold');
 const { memberProcessPrompt, MEMBER_PROCESS_PATH } = require('../lib/member-context');
 
 function findWorkspaceBusinessId(startDir = process.cwd()) {
@@ -306,6 +307,28 @@ function nearestMemberSlug(name, slugs) {
   return bestScore <= Math.max(2, Math.floor(needle.length / 3)) ? best : null;
 }
 
+// A person is never run as an agent. Reads the member's own type and returns
+// the plain refusal sentence, or '' when the member can run.
+function memberRefusalFor(name, memberFile) {
+  try {
+    return memberRefusalReason(name, parseFrontmatter(fs.readFileSync(memberFile, 'utf8')) || {});
+  } catch {
+    return '';
+  }
+}
+
+// Same as requireMemberDir, then stops with a non-zero exit for a human or
+// odd-typed member. Every path that runs a member as an agent starts here.
+function requireRunnableMember(name) {
+  const paths = requireMemberDir(name);
+  const reason = memberRefusalFor(name, paths.memberFile);
+  if (reason) {
+    console.error(reason);
+    process.exit(1);
+  }
+  return paths;
+}
+
 function requireMemberDir(name) {
   if (!name) {
     console.error('Usage: atris member <goal|tick|review> <name> ...');
@@ -1077,7 +1100,14 @@ function memberRun(name, ...args) {
   }
 
   const asJson = hasFlag(args, '--json');
-  const paths = requireMemberDir(name);
+  const paths = requireRunnableMember(name);
+  // Parking only hides a member from the team views; a run by name still goes.
+  const { isParkedText } = require('../lib/member-park');
+  try {
+    if (isParkedText(fs.readFileSync(paths.memberFile, 'utf8'))) {
+      console.error(`${name} is parked; running anyway`);
+    }
+  } catch { /* an unreadable card is requireMemberDir's problem, not this notice's */ }
   const requestedVerifier = readFlag(args, '--verify', '') || memberRunConfiguredVerifier(paths);
   const missionText = memberRunMissionText(args);
   const hasMissionOverride = Boolean(readFlag(args, '--mission', '') || readFlag(args, '--mission-id', ''));
@@ -4095,6 +4125,8 @@ function memberList(...flags) {
   const asJson = flags.includes('--json') || process.argv.includes('--json');
   const teamDir = path.join(process.cwd(), 'atris', 'team');
   const members = findAllMembers(teamDir);
+  const { isMemberParked } = require('../lib/member-park');
+  const parked = new Set(members.filter((m) => isMemberParked(process.cwd(), m.name)).map((m) => m.name));
 
   if (asJson) {
     console.log(JSON.stringify({
@@ -4102,6 +4134,7 @@ function memberList(...flags) {
       count: members.length,
       members: members.map((m) => ({
         name: m.name,
+        ...(parked.has(m.name) ? { parked: true } : {}),
         role: m.role,
         format: m.format,
         skills: m.format === 'directory' ? m.skillCount : null,
@@ -4149,12 +4182,14 @@ function memberList(...flags) {
       clipCell(m.format === 'directory' ? 'dir' : 'flat', fmtW) +
       clipCell(skills, skillW) +
       clipCell(context, ctxW) +
-      (m.version || '-')
+      (m.version || '-') +
+      (parked.has(m.name) ? '  parked' : '')
     );
   }
 
   console.log('');
-  console.log(`${members.length} ${members.length === 1 ? 'member' : 'members'} found.`);
+  const parkedNote = parked.size ? ` (${parked.size} parked; unpark with atris team unpark <name>)` : '';
+  console.log(`${members.length} ${members.length === 1 ? 'member' : 'members'} found.${parkedNote}`);
 }
 
 // --- CREATE subcommand ---
@@ -4209,6 +4244,8 @@ name: ${name}
 role: ${role}
 description: ${description || `Handles ${role.toLowerCase()} tasks`}
 version: 1.0.0
+# ai or human; a human member is a person and Atris never acts as them
+type: ai
 
 skills: []
 
@@ -4296,10 +4333,10 @@ tools: []
 }
 
 function printMemberInstallUsage(stream = console.log) {
-  stream('Usage: atris member install <slug>');
+  stream('Usage: atris member install <slug> [--update]');
 }
 
-function memberInstall(slug) {
+function memberInstall(slug, update = false) {
   if (slug === '--help' || slug === '-h') {
     printMemberInstallUsage();
     return;
@@ -4314,9 +4351,22 @@ function memberInstall(slug) {
   }
 
   const memberDir = path.join(process.cwd(), 'atris', 'team', slug);
+  const templateDir = path.join(__dirname, '..', 'templates', 'members', slug);
+  if (update) {
+    if (!fs.existsSync(templateDir)) {
+      console.error(`No member template for ${slug}.`);
+      process.exit(1);
+    }
+    const updated = updateMemberSkills(templateDir, memberDir);
+    if (updated.length === 0) {
+      console.log(`MEMBER ${slug} already up to date`);
+    } else {
+      for (const rel of updated) console.log(`atris/team/${slug}/${rel.split(path.sep).join('/')}`);
+    }
+    return;
+  }
   const already = memberBundlePresent(memberDir);
   fs.mkdirSync(path.join(memberDir, 'logs'), { recursive: true });
-  const templateDir = path.join(__dirname, '..', 'templates', 'members', slug);
   const copied = [];
   if (fs.existsSync(templateDir)) {
     const copyMissing = (source, relative = '') => {
@@ -7838,6 +7888,8 @@ function wakeMemberEngine(name, root = process.cwd()) {
 
 async function runMemberWake(name, { execute = false, confirmed = false, force = false, domainInput = {} } = {}) {
   const paths = requireMemberDir(name);
+  const refusal = memberRefusalFor(name, paths.memberFile);
+  if (refusal) throw new Error(refusal);
   const runtimeKind = paths.runtimeKind || memberRuntimeKind(name);
   if (runtimeKind === 'auto-improver') {
     return runAutoImproverWake(name, paths, { execute, confirmed });
@@ -8151,6 +8203,7 @@ function clipText(value, max = 70) {
 }
 
 async function memberWake(name, ...args) {
+  if (name) requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const execute = hasFlag(args, '--execute') && !hasFlag(args, '--dry-run');
   const confirmed = hasFlag(args, '--confirm-autonomy-policy');
@@ -8198,14 +8251,15 @@ function collectFleetActivationRows(root = process.cwd()) {
       const goalPlane = memberGoalPlaneStatus(slug, paths);
       const activeMission = memberLiveMission(slug, missionMap);
       const latestMission = memberLatestMission(slug, missionMap);
-      const skipped = !goalPlane.goal && !activeMission;
+      const refusal = memberRefusalFor(slug, paths.memberFile);
+      const skipped = Boolean(refusal) || (!goalPlane.goal && !activeMission);
       return {
         member: slug,
         goal: goalPlane.goal || null,
         active_mission: activeMission || null,
         latest_mission: latestMission || null,
         skipped,
-        skip_reason: skipped ? 'no_goal_and_no_active_mission' : null,
+        skip_reason: refusal ? 'not_ai' : skipped ? 'no_goal_and_no_active_mission' : null,
       };
     })
     .sort((a, b) => a.member.localeCompare(b.member));
@@ -8238,7 +8292,7 @@ async function memberLoopAll(kind, ...args) {
   for (const row of rows) {
     if (row.skipped) {
       skipped.push(row);
-      if (!asJson) console.log(`Skip ${row.member}: no goal and no active mission.`);
+      if (!asJson) console.log(`Skip ${row.member}: ${row.skip_reason === 'not_ai' ? 'not an AI member.' : 'no goal and no active mission.'}`);
       continue;
     }
     if (!asJson) console.log(`Activate ${row.member}: ${row.goal ? 'goal' : `mission ${row.active_mission?.id || 'active'}`}`);
@@ -8650,7 +8704,7 @@ function memberLoopRecordResult(name, paths, lease, run) {
 // Driver: the phases above do the work; this reads as setup -> gate -> run -> record.
 async function memberLoop(name, ...args) {
   if (name === '--all' || name === 'all') return memberLoopAll('loop', ...args);
-  requireMemberDir(name);
+  requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const aliveMode = hasFlag(args, '--alive');
   const execute = hasFlag(args, '--execute');
@@ -8714,7 +8768,7 @@ async function memberLoop(name, ...args) {
 }
 
 async function memberTick(name, ...args) {
-  const paths = requireMemberDir(name);
+  const paths = requireRunnableMember(name);
   const asJson = hasFlag(args, '--json');
   const force = hasFlag(args, '--force');
   const goalId = readFlag(args, '--goal', '');
@@ -9332,7 +9386,7 @@ async function memberCommand(subcommand, ...args) {
     case 'new':
       return memberCreate(args[0], ...args.slice(1));
     case 'install':
-      return memberInstall(args[0]);
+      return memberInstall(args[0], args.includes('--update'));
     case 'activate':
       return memberActivate(args[0]);
     case 'upgrade':
@@ -9394,7 +9448,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('');
       console.log('Subcommands:');
       console.log('  create <name>       Scaffold a new team member (MEMBER.md + dirs) [--push]');
-      console.log('  install <slug>      Install the full MEMBER bundle if missing; never overwrite');
+      console.log('  install <slug> [--update]  Install missing files, or refresh template skills');
       console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');
       console.log('  list [--json]       Show all team members');
       console.log('  activate <name>     Symlink member skills, show context and permissions');

package/commands/mission.js

@@ -22,6 +22,7 @@ const {
 const {
   resolveClaudeRunnerModel,
   resolvePinnedRunnerModel,
+  runnerModelFor,
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerCommand,
@@ -32,8 +33,11 @@ const {
 const {
   resolveEngineForRoleWithPreference,
   engineFailureHealthStatus,
+  engineStallReason,
+  recordEngineRunHealth,
   setEngineHealth,
 } = require('../lib/engine-registry');
+const { appendRosterRun, parseRunUsage } = require('../lib/roster-runs');
 const {
   FUNCTIONAL_MEMBER_TOPICS,
   listWorkspaceMemberSlugs,
@@ -391,9 +395,29 @@ function rosterTickPins(engine) {
   return {
     ...(engine && engine.roster_effort ? { roster_effort: engine.roster_effort } : {}),
     ...(engine && engine.roster_max_seconds ? { roster_max_seconds: engine.roster_max_seconds } : {}),
+    ...(engine && engine.roster_prep ? { roster_prep: engine.roster_prep } : {}),
   };
 }
 
+// A tick whose roster worker asks for prep ("prep: search") runs the same
+// prep pass fleet runs before the worker starts, and the worker's prompt
+// gets the brief. No prep line means the prompt goes out as it was.
+async function missionTickPrep(root, { mission, runtimeMission, job, prompt, ask } = {}) {
+  const prepJob = String(runtimeMission && runtimeMission.roster_prep || '').trim();
+  if (!prepJob) return { prompt, prep: null };
+  const { runPrepPass, withPrepBrief } = require('../lib/roster-prep');
+  const prep = await runPrepPass({
+    prepJob,
+    forJob: job || 'build',
+    task: { display_id: (mission && mission.id) || '', title: (mission && (mission.objective || mission.slug)) || '' },
+    prompt,
+    root,
+    record: { member: (mission && mission.owner) || '' },
+    ...(ask ? { ask } : {}),
+  });
+  return { prompt: withPrepBrief(prompt, prep), prep };
+}
+
 // A tick's time limit: the time left on the mission, capped by the roster
 // line's "max 20 min" when it sets one, else by the default tick cap.
 function missionTickTimeoutMs(mission, remainingMs) {
@@ -427,6 +451,7 @@ function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
         requested_engine: null,
         engine_fallback_reason: null,
         member_engine_reason: member.reason,
+        roster_job: member.job || 'build',
       };
     }
   }
@@ -445,10 +470,59 @@ function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
   };
 }
 
+// A stalled tick benches its engine for the cooldown, so the next tick's
+// roster pick is the backup; no retry inside the tick is needed.
 function recordMissionEngineTickOutcome(engineId, result, root = process.cwd()) {
   if (!engineId) return null;
-  const status = result && result.status === 'ran' ? 'ready' : engineFailureHealthStatus(result);
-  return status ? setEngineHealth(engineId, status, root) : null;
+  if (result && result.status === 'ran') return setEngineHealth(engineId, 'ready', root);
+  if (!engineFailureHealthStatus(result)) return null;
+  return recordEngineRunHealth(engineId, result, root);
+}
+
+// One run-record line per engine tick: how long the worker ran, and how it
+// ended. A tick that ran and passed (or had no verifier) landed; a failing
+// verifier or a real error failed; a time cap or dropped connection stalled;
+// a closed credit window is credit out. Never throws into the tick.
+function missionTickRunOutcome(result, verifierResult, maxSeconds) {
+  if (result && result.status === 'ran') {
+    return verifierResult && verifierResult.passed === false
+      ? { outcome: 'failed', detail: 'the verifier failed' }
+      : { outcome: 'landed' };
+  }
+  if (engineFailureHealthStatus(result) === 'credit_out') return { outcome: 'credit out', detail: 'the engine hit its usage limit' };
+  const stall = engineStallReason({ ...result, ...(maxSeconds ? { max_seconds: maxSeconds } : {}) });
+  if (stall) return { outcome: 'stalled', detail: stall.text };
+  if (/wall-exceeded/.test(String(result && result.reason || ''))) return { outcome: 'failed', detail: 'the mission ran out of time' };
+  const summary = String(result && result.claude && result.claude.summary || '').split('\n')[0].trim();
+  return { outcome: 'failed', detail: summary && summary !== 'error' ? summary : String(result && result.reason || 'the tick failed').replace(/-/g, ' ') };
+}
+
+function recordMissionTickRosterRun(root, { mission, runtimeMission, engineId, job, result, verifierResult, startedAt, endedMs, usage, prep = null } = {}) {
+  if (!engineId) return null;
+  try {
+    const { engineRunsView } = require('../lib/roster-models');
+    const { prepRecordFields } = require('../lib/roster-prep');
+    const run = runtimeMission || mission || {};
+    const startedMs = Date.parse(startedAt);
+    const maxSeconds = Number(run.roster_max_seconds) || 0;
+    return appendRosterRun(root, {
+      at: startedAt,
+      job: job || 'build',
+      member: (mission && mission.owner) || '',
+      engine: engineId,
+      model: run.model || engineRunsView(engineId).model || '',
+      effort: run.roster_effort || '',
+      max_seconds: maxSeconds,
+      seconds: Number.isFinite(startedMs) ? Math.max(0, (endedMs - startedMs) / 1000) : undefined,
+      task: (mission && mission.id) || '',
+      source: 'mission',
+      ...prepRecordFields(prep),
+      ...(usage || {}),
+      ...missionTickRunOutcome(result, verifierResult, maxSeconds),
+    });
+  } catch {
+    return null;
+  }
 }
 
 function runnerModelPatch(runner, model) {
@@ -495,6 +569,8 @@ function applyMissionRunnerProfile(runner) {
 // default model pin. Every other engine's CLI rejects a claude model name, so
 // it only ever takes an explicit pin (the mission's model or the roster
 // line's); '' lets the engine ride its own default.
+// A mission often still carries the claude model it was created with; an
+// engine that runs only its own models (codex) drops it.
 const CLAUDE_FAMILY_RUNNER_ENGINES = new Set(['claude', 'fable', 'haiku']);
 
 function resolveMissionTickRunnerModel(mission) {
@@ -502,7 +578,7 @@ function resolveMissionTickRunnerModel(mission) {
   if (!engine || CLAUDE_FAMILY_RUNNER_ENGINES.has(engine)) {
     return resolveClaudeRunnerModel(mission);
   }
-  return resolvePinnedRunnerModel(mission);
+  return runnerModelFor(engine, resolvePinnedRunnerModel(mission));
 }
 
 function exitMissionError(message, code = 1, asJson = false) {
@@ -8904,6 +8980,7 @@ function spawnGenericRunnerTick(mission, opts) {
         stop_reason: null,
         stderr: errStr,
         parse_errors: 0,
+        run_usage: parseRunUsage({ stdout, stderr }),
       });
     });
 
@@ -9008,6 +9085,7 @@ function spawnClaudeTick(mission, opts) {
     let numTurns = null;
     let rateLimitInfo = null;
     let stopReason = null;
+    let usage = null;
     let parseErrors = 0;
     let stderr = '';
     let timedOut = false;
@@ -9047,6 +9125,7 @@ function spawnClaudeTick(mission, opts) {
             if (typeof ev.duration_api_ms === 'number') durationApiMs = ev.duration_api_ms;
             if (typeof ev.num_turns === 'number') numTurns = ev.num_turns;
             if (ev.stop_reason) stopReason = ev.stop_reason;
+            if (ev.usage && typeof ev.usage === 'object') usage = ev.usage;
           }
         } catch {
           parseErrors++;
@@ -9083,6 +9162,7 @@ function spawnClaudeTick(mission, opts) {
         rate_limit_info: rateLimitInfo,
         stderr: errStr,
         parse_errors: parseErrors,
+        run_usage: parseRunUsage({ usage, cost_usd: costEstimate }),
       });
     });
 
@@ -9571,6 +9651,9 @@ async function executeMissionRunTicksPhase(context) {
       const tickStart = stampIso();
       const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
       let result = { status: 'skipped', reason: 'unknown', tick_index: tickIdx, ran: false, started_at: tickStart };
+      // Set when a roster engine really ran this tick: when it stopped and the
+      // usage it printed. The run record is written after the verifier.
+      let tickWorkerRun = null;
       let cachedStep = findCachedMissionStepReceipt(cwd, { missionId: mission.id, tickIndex: tickIdx });
       let cachedVerifierResult = cachedStep ? cachedStep.verifier_result : null;
       const tickSelection = resolveMissionTickRunner(runtimeMission, cwd);
@@ -9707,6 +9790,7 @@ async function executeMissionRunTicksPhase(context) {
             backend_unavailable: isTransientAtris2BackendError(turn.error) || undefined,
             receipt_text: String(turn.text || '').slice(0, 4000),
           };
+          tickWorkerRun = { endedMs: Date.now(), usage: {} };
           if (controller.signal.aborted) { pauseReason = 'aborted-during-atris2'; break; }
           if (turn.error === 'not-logged-in') { pauseReason = 'auth-required'; break; }
           if (wallExpired) {
@@ -9724,6 +9808,17 @@ async function executeMissionRunTicksPhase(context) {
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
         runtimeMission = runtimeView(mission);
+        let tickPrep = null;
+        let workerPrompt = prompt;
+        if (tickEngineId) {
+          ({ prompt: workerPrompt, prep: tickPrep } = await missionTickPrep(cwd, {
+            mission,
+            runtimeMission: tickRuntimeMission,
+            job: tickSelection.roster_job || 'build',
+            prompt,
+          }));
+        }
+        const workerStartedAt = tickPrep ? stampIso() : tickStart;
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
@@ -9734,7 +9829,7 @@ async function executeMissionRunTicksPhase(context) {
             tickRuntimeMission,
             (maxWallSeconds - ((Date.now() - startedAt) / 1000)) * 1000,
           ),
-          prompt,
+          prompt: workerPrompt,
           model: resolveMissionTickRunnerModel(tickRuntimeMission),
         });
         try {
@@ -9754,6 +9849,7 @@ async function executeMissionRunTicksPhase(context) {
         } finally {
           restoreTickRunnerProfile();
         }
+        tickWorkerRun = { endedMs: Date.now(), usage: (claudeResult && claudeResult.run_usage) || {}, prep: tickPrep, startedAt: workerStartedAt };
         result.claude = {
           ok: claudeResult.ok,
           reason: claudeResult.reason,
@@ -9860,6 +9956,20 @@ async function executeMissionRunTicksPhase(context) {
       }
       pauseReason = context.pauseReason;
       context.currentTick = null;
+      if (tickEngineId && !cachedStep && tickWorkerRun) {
+        recordMissionTickRosterRun(cwd, {
+          mission,
+          runtimeMission: tickRuntimeMission,
+          engineId: tickEngineId,
+          job: tickSelection.roster_job || 'build',
+          result,
+          verifierResult,
+          startedAt: tickWorkerRun.startedAt || tickStart,
+          endedMs: tickWorkerRun.endedMs,
+          usage: tickWorkerRun.usage,
+          prep: tickWorkerRun.prep || null,
+        });
+      }
       let receiptPath = cachedStep ? cachedStep.receipt_path : null;
 
       // Review-lane drain: always-on loops sweep the agent-safe review actions
@@ -11792,6 +11902,8 @@ module.exports = {
   missionTickTimeoutMs,
   engineFailureHealthStatus,
   recordMissionEngineTickOutcome,
+  recordMissionTickRosterRun,
+  missionTickPrep,
   tickMadeProgress,
   consecutiveNoProgressTicks,
   consecutiveIdenticalSummaryTicks,