atris 3.64.0 → 3.66.0

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

@@ -97,6 +97,16 @@ function engineRunsView(engineId, { model = '', effort = '' } = {}, options = {}
   return view;
 }
 
+// "<engine> · <model label>" for a table cell: the tool, a middle dot, and the
+// model label, or "own default" when the tool picks its model itself.
+// Effort is left out; tables give it its own line.
+function engineModelText(engine, model = '') {
+  const id = String(engine || '').trim();
+  if (!id) return '';
+  const label = model ? modelLabel(model) : '';
+  return `${id} · ${label || 'own default'}`;
+}
+
 function runsDetail(view) {
   const items = [{ text: view.model ? modelLabel(view.model) : 'its own default', source: view.model ? view.model_source : 'roster' }];
   if (view.effort) items.push({ text: view.effort, source: view.effort_source });
@@ -114,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.
@@ -172,6 +182,7 @@ function availableModels(engines, options = {}) {
 }
 
 module.exports = {
+  engineModelText,
   modelLabel,
   readCodexSettings,
   engineRunsView,

package/lib/roster-stale.js

@@ -0,0 +1,241 @@
+'use strict';
+
+// Outdated models on the roster. A roster worker whose model has a newer
+// version among the models this machine or the engine registry already
+// knows gets one plain line and the command that moves it forward. A pinned
+// model whose newest proof (a "verified <date>" on its line, or a landed run
+// on that model) is over 30 days old gets one line too. Nothing here goes
+// online: the model lists come from availableModels (codex's own models
+// cache, the claude names atris knows, and each engine's registry models).
+
+const { modelLabel, availableModels } = require('./roster-models');
+const { parseRosterUntil, rosterMaxText, rosterToolLabel } = require('./engine-registry');
+
+const PIN_MAX_AGE_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+
+// Family ordering across names is ambiguous: going from a "luna" tail to a
+// "sol" tail one version up is a tier change as much as a version change,
+// and nothing local says which tails rank above which. So versions are only
+// compared within an identical name prefix, the text before the first
+// version number: "x-6-astra" and "x-6.1-sol" share the prefix "x", and two
+// names with different prefixes (sonnet and opus) never compare. Among
+// newer versions, one that keeps the same tail (sol, fast, flash-high) wins;
+// otherwise the highest version, and on a tie the one the list names first.
+// Examples stay abstract here so this file never pins a real model name.
+// A context tag at the end ("[1m]", "(beta)") is not part of the name, and
+// a leading "claude-" before a family word is the vendor, not the family,
+// so "claude-x-4-6[1m]" and "x 5" land in the same family.
+function familyLabel(model) {
+  let text = String(model || '').trim();
+  while (/\s*(?:\[[^\]]*\]|\([^)]*\))$/.test(text)) text = text.replace(/\s*(?:\[[^\]]*\]|\([^)]*\))$/, '');
+  return modelLabel(text).toLowerCase().trim().replace(/^claude[\s_-]+(?=[a-z])/, '');
+}
+
+function modelFamily(model) {
+  const label = familyLabel(model);
+  const match = /^([a-z][a-z/_\s-]*?)[\s_-]*(\d+(?:[.-]\d{1,2}(?!\d))*)(.*)$/.exec(label);
+  if (!match) return null;
+  const prefix = match[1].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (!prefix) return null;
+  return {
+    prefix,
+    version: match[2].split(/[.-]/).map(Number),
+    variant: match[3].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, ''),
+  };
+}
+
+function compareVersions(a, b) {
+  const size = Math.max(a.length, b.length);
+  for (let i = 0; i < size; i += 1) {
+    const diff = (a[i] || 0) - (b[i] || 0);
+    if (diff) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function sameModel(a, b) {
+  const left = modelLabel(a).toLowerCase().trim();
+  return Boolean(left) && left === modelLabel(b).toLowerCase().trim();
+}
+
+// The newest model in the list that beats this one, or null.
+function newerModel(model, catalog = []) {
+  const current = modelFamily(model);
+  if (!current) return null;
+  let best = null;
+  for (const candidate of catalog || []) {
+    const family = modelFamily(candidate);
+    if (!family || family.prefix !== current.prefix) continue;
+    if (compareVersions(family.version, current.version) <= 0) continue;
+    const sameTail = family.variant === current.variant;
+    const better = !best
+      || (sameTail && !best.sameTail)
+      || (sameTail === best.sameTail && compareVersions(family.version, best.family.version) > 0);
+    if (better) best = { candidate, family, sameTail };
+  }
+  return best ? best.candidate : null;
+}
+
+// Every model each engine is known to offer, from local files only. Claude,
+// fable, and haiku run through the same CLI, so they share one list.
+function modelCatalog(engines, options = {}) {
+  const catalog = {};
+  const add = (id, models) => {
+    const list = catalog[id] || (catalog[id] = []);
+    for (const model of models || []) if (model && !list.includes(model)) list.push(model);
+  };
+  const rows = availableModels(engines || [], options);
+  for (const row of rows) add(row.engine, row.models);
+  for (const engine of engines || []) add(engine.id, engine.models);
+  const claude = (rows.find((row) => row.engine === 'claude') || {}).models || [];
+  for (const id of CLAUDE_FAMILY) if (catalog[id]) add(id, claude);
+  return catalog;
+}
+
+function localDayText(date) {
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+function wholeDaysSince(dayText, now) {
+  const day = parseRosterUntil(dayText);
+  if (!day) return null;
+  const date = new Date(now);
+  const today = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  return Math.round((today.getTime() - day.getTime()) / DAY_MS);
+}
+
+// The newest proof that this engine and model answer: the line's own
+// "verified" date or the newest landed run on the same engine and model.
+function pinVerified(worker, runs) {
+  let best = worker.verified ? { at: worker.verified, source: 'roster line' } : null;
+  for (const run of runs || []) {
+    if (run.outcome !== 'landed' || run.engine !== worker.engine || !sameModel(run.model, worker.model)) continue;
+    const at = Date.parse(run.at);
+    if (!Number.isFinite(at)) continue;
+    const day = localDayText(new Date(at));
+    if (!best || day > best.at) best = { at: day, source: 'landed run' };
+  }
+  return best;
+}
+
+function quoteArg(text) {
+  const value = String(text || '');
+  return /^[A-Za-z0-9._:/@-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+
+const SCOPE_FLAGS = Object.freeze({ 'all projects': '--everywhere', 'this session': '--session' });
+
+// The assign command that moves a job's first worker to the newer model and
+// keeps everything else on its line: effort, time cap, prep, end date.
+function assignCommand(row, worker, model) {
+  const parts = ['atris engine assign', quoteArg(row.job), worker.engine, '--model', quoteArg(modelLabel(model))];
+  if (worker.effort) parts.push('--effort', worker.effort);
+  if (worker.max_seconds) parts.push('--max', quoteArg(rosterMaxText(worker.max_seconds).replace(/^max /, '')));
+  if (worker.prep) parts.push('--prep', quoteArg(worker.prep));
+  if (worker.until && Number(worker.ends_in_days) > 0) parts.push('--days', String(worker.ends_in_days));
+  if (SCOPE_FLAGS[row.from]) parts.push(SCOPE_FLAGS[row.from]);
+  return parts.join(' ');
+}
+
+function lineHint(file, line, change) {
+  const where = line ? `line ${line} of ${file || 'the roster'}` : (file || 'the roster');
+  return `${change} on ${where}`;
+}
+
+// Mark every worker and job in a roster report with stale_model,
+// newer_model, pin_age_days, and pin_verified_at, and list what needs a
+// look in report.stale. Returns the report.
+function attachStaleModels(report, { catalog = {}, runs = [], now = new Date() } = {}) {
+  const stale = [];
+  const today = localDayText(new Date(now));
+  for (const row of report.jobs || []) {
+    (row.workers || []).forEach((worker, index) => {
+      worker.stale_model = false;
+      worker.newer_model = null;
+      worker.pin_age_days = null;
+      worker.pin_verified_at = null;
+      const view = worker.runs;
+      if (!view || !view.model || !worker.engine || worker.why === 'expired') return;
+      const who = index === 0 ? row.job : `${row.job} backup`;
+      const tool = rosterToolLabel(worker.engine);
+      const newer = newerModel(view.model, catalog[worker.engine]);
+      if (newer) {
+        worker.stale_model = true;
+        worker.newer_model = newer;
+        const from = view.model_source === 'roster' ? '' : ` from ${view.model_source}`;
+        const renew = index === 0
+          ? assignCommand(row, worker, newer)
+          : lineHint(row.file, worker.line, `change the model to ${modelLabel(newer)}`);
+        stale.push({
+          kind: 'newer model',
+          job: row.job,
+          engine: worker.engine,
+          model: view.model,
+          newer_model: newer,
+          from: row.from,
+          file: row.file,
+          line: worker.line,
+          renew,
+          text: `${who}: ${tool} runs ${modelLabel(view.model)}${from}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+        });
+      }
+      if (view.model_source !== 'roster') return;
+      const proof = pinVerified({ ...worker, model: view.model }, runs);
+      if (!proof) return;
+      worker.pin_verified_at = proof.at;
+      worker.pin_age_days = wholeDaysSince(proof.at, now);
+      if (worker.pin_age_days === null || worker.pin_age_days <= PIN_MAX_AGE_DAYS || newer) return;
+      stale.push({
+        kind: 'old pin',
+        job: row.job,
+        engine: worker.engine,
+        model: view.model,
+        pin_verified_at: proof.at,
+        pin_age_days: worker.pin_age_days,
+        from: row.from,
+        file: row.file,
+        line: worker.line,
+        text: `${who}: ${tool} on ${modelLabel(view.model)} was last verified ${worker.pin_age_days} days ago (${proof.source}). smoke one prompt, then ${lineHint(row.file, worker.line, `add "verified ${today}"`)}`,
+      });
+    });
+    // The job's own fields mirror the worker that leads it, else its first.
+    const lead = (row.workers || []).find((worker) => worker.status === 'leads') || (row.workers || [])[0] || {};
+    row.stale_model = Boolean(lead.stale_model);
+    row.newer_model = lead.newer_model || null;
+    row.pin_age_days = lead.pin_age_days === undefined ? null : lead.pin_age_days;
+  }
+  // A member line that pins its own model is checked too; a member that
+  // picks automatically runs its job's worker, already checked above.
+  for (const member of report.team || []) {
+    if (member.source !== 'file' || !member.model || !member.engine) continue;
+    const newer = newerModel(member.model, catalog[member.engine]);
+    member.stale_model = Boolean(newer);
+    member.newer_model = newer;
+    if (!newer) continue;
+    const renew = `change the model to ${modelLabel(newer)} on the ${member.member} line of ${member.file || 'the roster'}`;
+    stale.push({
+      kind: 'newer model',
+      member: member.member,
+      engine: member.engine,
+      model: member.model,
+      newer_model: newer,
+      file: member.file,
+      renew,
+      text: `${member.member}: ${rosterToolLabel(member.engine)} runs ${modelLabel(member.model)}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+    });
+  }
+  report.stale = stale;
+  return report;
+}
+
+module.exports = {
+  PIN_MAX_AGE_DAYS,
+  attachStaleModels,
+  compareVersions,
+  modelCatalog,
+  modelFamily,
+  newerModel,
+};

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