atris 3.65.0 → 3.66.0

package/lib/idle-review-sweep.js

@@ -0,0 +1,130 @@
+'use strict';
+
+// Finished work that can never land on its own should not wait forever.
+// Every hourly autoland tick: a review row idle past the grace period whose
+// check this machine cannot rerun from main is closed with a plain reason.
+// Landable rows are left for the landing pass, protected lanes (money,
+// deploys, security, customer, outward) are left for the human, and anything
+// still moving (touched inside the grace period) is left alone.
+
+const taskDb = require('./task-db');
+const { evaluateAutoAccept, protectedLaneOf, verifyRunnability } = require('./auto-accept-certified');
+const { plainLandingReason } = require('./voice-gate');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_IDLE_CLOSE_DAYS = 7;
+
+// Reasons that mean "no machine can ever check this from main as it stands".
+// A human or the builder can still reopen it with a check that runs.
+const UNVERIFIABLE_REASONS = new Set([
+  'verify_command_not_allowed',
+  'verify_only_on_agent_branch',
+  'verify_failed_on_main',
+  'verify_workdir_missing',
+  'verify_worktree_missing',
+  'strict_verify_missing',
+  'no_verify_command',
+]);
+
+function idleCloseMs(policy = {}) {
+  const days = Number(policy && policy.idle_close_days);
+  return (Number.isFinite(days) && days > 0 ? days : DEFAULT_IDLE_CLOSE_DAYS) * DAY_MS;
+}
+
+const CLOSE_WHY = {
+  verify_command_not_allowed: 'its check is a kind this machine may not run on its own',
+  verify_only_on_agent_branch: "its check runs a file that only exists on the agent's branch, never on main",
+  verify_failed_on_main: 'its check fails when rerun from the main project, so the work never reached main',
+  verify_workdir_missing: 'the folder its check ran in is gone',
+  verify_worktree_missing: 'the agent copy its check ran in is gone',
+  strict_verify_missing: 'it has no check to rerun',
+  no_verify_command: 'it has no check to rerun',
+};
+
+function closeReason(reason, days) {
+  const why = CLOSE_WHY[reason] || plainLandingReason(reason) || reason;
+  return `Closed after ${days} days waiting, because ${why}, so it could never land on its own. Reopen it with a check that runs from the main project if the work still matters.`;
+}
+
+function toMs(value) {
+  if (value === null || value === undefined || value === '') return 0;
+  const n = Number(value);
+  if (Number.isFinite(n)) return n;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+// Idle means nobody worked on it, not that no machine touched it: the hourly
+// re-check stamps updated_at on every row whose check runs, which would keep
+// a never-landable row "fresh" forever. Count only people and builders.
+function lastActivityAt(task, now = Date.now()) {
+  const metadata = task.metadata || {};
+  const at = Math.max(
+    toMs(task.created_at),
+    toMs(task.claimed_at),
+    toMs(metadata.agent_reviewed_at),
+    toMs(metadata.stage_updated_at),
+    toMs(metadata.planned_at),
+    toMs(metadata.human_revision_at),
+    toMs(metadata.backlogged_at),
+  );
+  return at > 0 ? at : now;
+}
+
+// Pure decision for one projection row. `liveReasons` carries the landing
+// pass's executed verdicts from this tick (verify_failed_on_main can only be
+// known by running the check), keyed by ref.
+function idleDecision(task, { root, policy = {}, now = Date.now(), liveReasons = new Map() } = {}) {
+  if (!task || task.status !== 'review') return { action: 'skip', why: 'not_review' };
+  const approval = String(task.review?.approval_status || task.metadata?.approval_status || 'pending');
+  if (approval !== 'pending' && approval !== 'agent_certified') return { action: 'skip', why: 'decided' };
+  const lane = protectedLaneOf(task);
+  if (lane) return { action: 'human', lane };
+  const idleMs = now - lastActivityAt(task, now);
+  if (!(idleMs > idleCloseMs(policy))) return { action: 'wait', why: 'still_in_grace' };
+  const ref = task.display_id || task.legacy_ref || task.id;
+  let reason = liveReasons.get(ref) || null;
+  if (!reason) {
+    const evaluation = evaluateAutoAccept(
+      { ...task, workspace_root: root },
+      { strictVerify: policy.strict_verify !== false, acceptAll: Boolean(policy.accept_all), executeVerify: false },
+    );
+    if (evaluation.eligible) return { action: 'land', why: 'landing_pass_takes_it' };
+    reason = verifyRunnability({ ...task, workspace_root: root }) || evaluation.reason;
+  }
+  if (!UNVERIFIABLE_REASONS.has(reason)) return { action: 'wait', why: reason };
+  return { action: 'close', reason, days: Math.floor(idleMs / DAY_MS) };
+}
+
+function sweepIdleReviews(root, { tasks, policy = {}, now = Date.now(), liveReasons = new Map(), dryRun = false, actor = 'autoland' } = {}) {
+  const closed = [];
+  const humanWaiting = [];
+  const due = [];
+  for (const task of tasks || []) {
+    const decision = idleDecision(task, { root, policy, now, liveReasons });
+    const ref = task.display_id || task.legacy_ref || task.id;
+    if (decision.action === 'human') humanWaiting.push({ ref, lane: decision.lane });
+    if (decision.action === 'close') due.push({ id: task.id, ref, title: task.title || '', reason: decision.reason, text: closeReason(decision.reason, decision.days) });
+  }
+  if (dryRun || !due.length) return { closed: dryRun ? due : closed, due: due.length, human_waiting: humanWaiting, dry_run: dryRun };
+
+  const db = taskDb.open();
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    for (const item of due) {
+      const result = taskDb.archiveTask(db, { id: item.id, actor, reason: item.text, skipLogs: true });
+      if (result.archived) closed.push(item);
+    }
+    db.exec('COMMIT');
+  } catch (error) {
+    try { db.exec('ROLLBACK'); } catch { /* surface the original error */ }
+    throw error;
+  }
+  return { closed, due: due.length, human_waiting: humanWaiting, dry_run: false };
+}
+
+module.exports = {
+  idleDecision,
+  lastActivityAt,
+  sweepIdleReviews,
+};

package/lib/known-commands.js

@@ -5,7 +5,7 @@ const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'work
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi'];
+                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an
 // adjacent transposition (e.g. "taks" -> "task") as a single edit, since

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