atris 3.58.7 → 3.59.0

package/commands/engine.js

@@ -7,6 +7,13 @@
 // same names ride --engine on mission run / autopilot / run.
 //
 //   atris engine            roster + current default
+//   atris engine roster     show every job's workers, built-in jobs first
+//   atris engine roster confirm  renew every dated worker for 30 days
+//   atris engine roster session [clear]  this shell's own changes
+//   atris engine roster --available  tools and models on this machine
+//   atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]
+//   atris engine assign <job> --remove <tool> | --clear [--session | --everywhere]
+//   jobs are open-ended: search, build, review, or your own ("small build")
 //   atris engine cursor     make cursor the default engine here
 //   atris engine reset      back to the house default (atris-fast)
 //
@@ -27,8 +34,30 @@ const {
 } = require('../lib/runner-command');
 const { parseScopeFlag } = require('../lib/cli-scope');
 const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
+const { teamRosterView } = require('../lib/member-engine');
+const { engineRunsView, availableModels } = require('../lib/roster-models');
 const {
   ENGINE_ROLES,
+  ENGINE_JOBS,
+  ROSTER_SOURCES,
+  ROSTER_LAYERS,
+  rosterDecided,
+  rosterWorkerWalk,
+  rosterToolLabel,
+  rosterSessionKey,
+  clearSessionRoster,
+  NO_SESSION_MESSAGE,
+  rosterJobKey,
+  rosterJobLabel,
+  rosterJobNameError,
+  rosterJobRole,
+  readRosterState,
+  customRosterJobKeys,
+  setRosterPick,
+  confirmRoster,
+  rosterMaxText,
+  rosterPinFor,
+  parseRosterUntil,
   ENGINE_DUTIES,
   ENGINE_HEALTH_STATUSES,
   binInstalled,
@@ -908,6 +937,7 @@ async function runEngineSeedCommand(args, root, deps = {}) {
 
 function printRoster(root, { scope = 'workspace' } = {}) {
   reconcileStaleEngineProbeErrors(root);
+  printJobRoster(root);
   const list = roster(root);
   const scoped = scope === 'global'
     ? list
@@ -952,10 +982,336 @@ function registryPayload(root, { scope = 'workspace', includeHidden = false } =
     scope,
     default: current.name,
     source: current.source,
+    roster: jobRosterView(root),
     engines: scoped,
   };
 }
 
+// A hand-edited file can hold a string or a list where a pick belongs. Only
+// an object naming an engine counts; anything else shows as no pick.
+function rosterPickEntry(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) && value.engine ? value : null;
+}
+
+const WORKER_SKIP_WORDS = Object.freeze({ 'not ready': 'down', expired: 'expired', 'bad model': 'names a model it cannot run' });
+
+// One worker of a job's team as the view shows it: what it runs, and whether
+// it leads now, backs up, or is skipped and why.
+function workerRow(step, index, leadIndex) {
+  const { worker } = step;
+  const runs = worker.error ? null : engineRunsView(worker.engine, { model: worker.model || '', effort: worker.effort || '' });
+  const status = index === leadIndex ? 'leads' : step.skip ? 'skipped' : 'backup';
+  const why = step.skip === 'bad line' ? `bad line: ${worker.error}` : step.skip ? WORKER_SKIP_WORDS[step.skip] : '';
+  return {
+    engine: worker.engine || null,
+    model: worker.model || null,
+    effort: worker.effort || null,
+    max_seconds: Number(worker.max_seconds) > 0 ? Number(worker.max_seconds) : null,
+    until: worker.until || null,
+    line: worker.line || null,
+    ...(worker.error ? { text: worker.text || '' } : {}),
+    status,
+    why,
+    runs,
+  };
+}
+
+function jobRosterRow(job, role, root, state, registry, now, key = role) {
+  const custom = key !== role || !ENGINE_ROLES.includes(key);
+  const layerPicks = Object.fromEntries(ROSTER_LAYERS.map((scope) => [scope, (state[scope] && state[scope].picks) || {}]));
+  const picks = Object.fromEntries(ROSTER_LAYERS.map((scope) => [scope, rosterPickEntry(layerPicks[scope][key])]));
+  const resolved = resolveEngineForRoleRanked(role, root, {
+    now,
+    sessionRosterPicks: layerPicks.session,
+    projectRosterPicks: layerPicks.project,
+    machineRosterPicks: layerPicks.machine,
+    ...(custom ? { job: key } : {}),
+  });
+  // Show the layer that decided; when none did, show the first one set. A
+  // custom job that fell back to its kind's pick did not decide on its own.
+  const decided = rosterDecided(resolved.source) && (!custom || resolved.job === job);
+  const source = decided ? resolved.source : ROSTER_LAYERS.find((scope) => picks[scope]) || null;
+  const pick = source ? picks[source] : null;
+  const walk = pick ? rosterWorkerWalk(pick, role, registry, now) : [];
+  const leadIndex = decided && resolved.source === source ? walk.findIndex((step) => !step.skip) : -1;
+  const good = walk.map((step, index) => ({ step, index })).filter(({ step }) => !step.worker.error);
+  const first = good[0] || null;
+  const status = !pick ? 'router'
+    : first && first.step.skip === 'expired' ? 'expired'
+      : first && leadIndex === first.index ? 'picked'
+        : 'not ready';
+  const lead = leadIndex === -1 ? 'none'
+    : first && leadIndex === first.index ? 'first'
+      : good[1] && leadIndex === good[1].index ? 'backup'
+        : 'later';
+  const kind = Object.keys(ENGINE_JOBS).find((name) => ENGINE_JOBS[name] === role);
+  // What the job really runs: its first two good workers, each with its own
+  // model and effort, or the router's engine when no line decides.
+  const runsOf = (entry) => (entry ? engineRunsView(entry.step.worker.engine, { model: entry.step.worker.model || '', effort: entry.step.worker.effort || '' }) : null);
+  const runs = runsOf(first);
+  const nowRuns = resolved.engine
+    ? engineRunsView(resolved.engine.id, { model: resolved.engine.roster_model || '', effort: resolved.engine.roster_effort || '' })
+    : null;
+  return {
+    job,
+    role,
+    ...(custom ? { key, like: kind } : {}),
+    pick,
+    from: source ? ROSTER_SOURCES[source] : null,
+    file: source ? state[source].file : null,
+    session_pick: picks.session,
+    project_pick: picks.project,
+    machine_pick: picks.machine,
+    engine: resolved.engine ? resolved.engine.id : null,
+    model: resolved.engine && resolved.engine.roster_model ? resolved.engine.roster_model : null,
+    effort: resolved.engine && resolved.engine.roster_effort ? resolved.engine.roster_effort : null,
+    max_seconds: pick && Number(pick.max_seconds) > 0 ? Number(pick.max_seconds) : null,
+    runs: runs || nowRuns,
+    backup_runs: runsOf(good[1]),
+    now_runs: nowRuns,
+    workers: walk.map((step, index) => workerRow(step, index, leadIndex)),
+    lead,
+    status,
+    reason: resolved.reason,
+  };
+}
+
+// The three built-in jobs first, then the owner's own jobs from this
+// session, this project, and the all-projects roster.
+function jobRosterView(root = process.cwd(), now = new Date(), state = null) {
+  const registry = readEngineRegistry(root);
+  const layers = state || readRosterState(root, { now });
+  const rows = Object.entries(ENGINE_JOBS).map(([job, role]) => jobRosterRow(job, role, root, layers, registry, now));
+  const customKeys = [...new Set(ROSTER_LAYERS.flatMap((scope) => customRosterJobKeys(layers[scope] && layers[scope].picks)))];
+  for (const key of customKeys) {
+    const role = rosterJobRole(key, root, {
+      now,
+      sessionRosterPicks: layers.session.picks,
+      projectRosterPicks: layers.project.picks,
+      machineRosterPicks: layers.machine.picks,
+    });
+    if (!role) continue;
+    rows.push(jobRosterRow(rosterJobLabel(key), role, root, layers, registry, now, key));
+  }
+  return rows;
+}
+
+// Jobs, the team, and one warning per roster line that could not be used.
+function rosterReport(root = process.cwd(), now = new Date()) {
+  const state = readRosterState(root, { now });
+  const jobs = jobRosterView(root, now, state);
+  const team = teamRosterView(root, { now, rosterState: state });
+  return {
+    jobs,
+    team: team.rows,
+    warnings: [...state.session.warnings, ...state.project.warnings, ...state.machine.warnings, ...team.warnings],
+    files: {
+      session: state.session.format === 'none' ? null : state.session.file,
+      project: state.project.format === 'none' ? null : state.project.file,
+      machine: state.machine.format === 'none' ? null : state.machine.file,
+    },
+    session: state.session.key || null,
+  };
+}
+
+function untilText(worker) {
+  const until = parseRosterUntil(worker.until);
+  if (until) return `until ${until.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }).toLowerCase()}`;
+  return worker.never_expires ? 'no end date' : 'until no valid date';
+}
+
+// Every worker under its job, numbered in order, when the job has more than
+// the lead and one backup (the job's own line already shows those two).
+function renderWorkerLines(row) {
+  if (!row.workers || row.workers.length <= 2) return [];
+  const width = Math.max(...row.workers.map((worker) => (worker.runs ? worker.runs.text : worker.text || '').length));
+  return row.workers.map((worker, index) => {
+    const what = (worker.runs ? worker.runs.text : worker.text || '').padEnd(width);
+    const extras = [worker.max_seconds ? rosterMaxText(worker.max_seconds) : '', worker.until ? `until ${worker.until}` : ''].filter(Boolean);
+    const state = worker.status === 'leads' ? 'leads now' : worker.status === 'backup' ? 'backup' : `skipped, ${worker.why}`;
+    return `  ${index + 1}. ${what} ${[state, ...extras].join(', ')}`.trimEnd();
+  });
+}
+
+function renderJobRoster(rows) {
+  const width = Math.max(7, ...rows.map((row) => row.job.length));
+  const ownerWidth = Math.max(24, ...rows.filter((row) => row.pick && row.runs).map((row) => row.runs.text.length));
+  const backupWidth = Math.max(16, ...rows.filter((row) => row.backup_runs).map((row) => row.backup_runs.text.length + 7));
+  return rows.map((row) => {
+    const label = row.job.padEnd(width);
+    const nowText = row.now_runs ? row.now_runs.text : 'no ready engine';
+    const fallsTo = `${row.like ? `falls back to ${row.like}` : 'router decides'}: ${nowText}`;
+    if (!row.pick) return `${label} no pick, ${fallsTo}`;
+    const owner = row.runs.text.padEnd(ownerWidth);
+    const backup = row.backup_runs ? `backup ${row.backup_runs.text}` : 'no backup';
+    const cap = row.max_seconds ? `${rosterMaxText(row.max_seconds)}, ` : '';
+    const date = untilText(row.pick);
+    const fallback = row.lead === 'backup' ? 'using backup' : row.lead === 'later' ? `using ${nowText}` : fallsTo;
+    const status = row.status === 'expired' ? `expired, ${fallback}`
+      : row.status === 'not ready' ? `not ready, ${fallback}`
+        : date;
+    const where = row.file ? `${row.from} (${row.file})` : row.from;
+    const head = `${label} ${owner} ${backup.padEnd(backupWidth)} ${cap}${status}, ${where}`.trimEnd();
+    return [head, ...renderWorkerLines(row)].join('\n');
+  }).join('\n');
+}
+
+function renderTeamRoster(rows) {
+  if (!rows.length) return '';
+  const width = Math.max(6, ...rows.map((row) => row.member.length));
+  const jobWidth = Math.max(6, ...rows.map((row) => String(row.job || '').length));
+  const lines = rows.map((row) => {
+    const engine = row.engine ? engineRunsView(row.engine, { model: row.model || '', effort: row.effort || '' }).text : 'no ready engine';
+    const how = row.source === 'file' ? `from ${row.file}` : 'automatic';
+    return `${row.member.padEnd(width)} ${String(row.job || '').padEnd(jobWidth)} ${engine.padEnd(24)} ${how}`.trimEnd();
+  });
+  return ['team', ...lines].join('\n');
+}
+
+function renderRosterWarnings(warnings) {
+  return warnings.map((warning) => `warning: ${warning.file} line ${warning.line} "${warning.text}" ${warning.message}.`).join('\n');
+}
+
+function renderRosterReport(report) {
+  return [renderJobRoster(report.jobs), renderTeamRoster(report.team), renderRosterWarnings(report.warnings)]
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function printJobRoster(root, now = new Date()) {
+  console.log(renderRosterReport(rosterReport(root, now)));
+}
+
+const AVAILABLE_HINT = 'see which tools and models this machine has: atris engine roster --available';
+
+// Each installed tool and the models it offers, from local files only.
+function availableReport(root) {
+  const engines = readEngineRegistry(root, { persist: false }).engines
+    .filter((engine) => !HIDDEN_PROFILE_NAMES.includes(engine.id))
+    .filter((engine) => engine.installed || (engine.health && engine.health.status === 'ready'));
+  return availableModels(engines).map((row) => ({ ...row, tool: rosterToolLabel(row.engine) }));
+}
+
+function renderAvailable(rows) {
+  if (!rows.length) return 'no tools found on this machine. run atris engine doctor to check again';
+  const width = Math.max(...rows.map((row) => row.tool.length));
+  return ['on this machine', ...rows.map((row) => `${row.tool.padEnd(width)}  ${row.models.join(', ') || 'its own default'}  (${row.source})`)].join('\n');
+}
+
+// Only this session's changes, from its own file.
+function renderSessionRoster(report, key) {
+  const jobs = report.jobs.filter((row) => row.from === ROSTER_SOURCES.session);
+  const team = report.team.filter((row) => row.source === 'file' && row.file === report.files.session);
+  if (!jobs.length && !team.length) return `this session (${key}) has no roster changes. add one with: atris engine assign <job> <tool> --session`;
+  const head = `this session (${key}) changes${report.files.session ? `, from ${report.files.session}` : ''}`;
+  return [head, renderJobRoster(jobs), renderTeamRoster(team)].filter(Boolean).join('\n\n');
+}
+
+function runRosterSessionCommand(rest, json, root, now) {
+  const key = rosterSessionKey();
+  if (rest[1] === 'clear') {
+    try {
+      const cleared = clearSessionRoster();
+      console.log(cleared ? 'cleared this session\'s roster changes' : 'this session has no roster changes to clear');
+      return 0;
+    } catch (err) {
+      console.error(err.message);
+      return 2;
+    }
+  }
+  if (!key) {
+    console.error(NO_SESSION_MESSAGE);
+    return 2;
+  }
+  const report = rosterReport(root, now);
+  if (json) {
+    const jobs = report.jobs.filter((row) => row.from === ROSTER_SOURCES.session);
+    const team = report.team.filter((row) => row.source === 'file' && row.file === report.files.session);
+    console.log(JSON.stringify({ session: key, file: report.files.session, jobs, team }, null, 2));
+  } else {
+    console.log(renderSessionRoster(report, key));
+  }
+  return 0;
+}
+
+function runRosterCommand(args, root, now = new Date()) {
+  const json = args.includes('--json');
+  const available = args.includes('--available');
+  const rest = args.filter((arg) => arg !== '--json' && arg !== '--available');
+  const known = !rest.length
+    || (rest.length === 1 && ['confirm', 'session'].includes(rest[0]))
+    || (rest.length === 2 && rest[0] === 'session' && rest[1] === 'clear');
+  if (!known || (available && rest.length)) {
+    console.error('usage: atris engine roster [confirm | session [clear] | --available] [--json]');
+    return 2;
+  }
+  if (available) {
+    const rows = availableReport(root);
+    console.log(json ? JSON.stringify({ tools: rows }, null, 2) : renderAvailable(rows));
+    return 0;
+  }
+  if (rest[0] === 'session') return runRosterSessionCommand(rest, json, root, now);
+  if (rest[0] === 'confirm') confirmRoster(root, now);
+  const report = rosterReport(root, now);
+  if (json) console.log(JSON.stringify(report, null, 2));
+  else console.log(`${renderRosterReport(report)}\n\n${AVAILABLE_HINT}`);
+  return 0;
+}
+
+const ASSIGN_USAGE = 'usage: atris engine assign <job> <tool> [--model <m>] [--effort low|medium|high|xhigh|max] [--max "20 min"] [--days <n>] [--add] [--backup "<tool> [model]"] [--like search|build|review] [--session | --everywhere], or atris engine assign <job> --remove <tool> | --clear. jobs live in atris/ROSTER.md (~/.atris/ROSTER.md with --everywhere, this shell only with --session) and you can edit that file any time';
+
+function runAssignCommand(args, root, now = new Date()) {
+  const job = args[0] && !String(args[0]).startsWith('--') ? args[0] : '';
+  if (!job) {
+    console.error('name the job first: atris engine assign <job> <tool>. jobs: search, build, review, or your own, like "small build"');
+    return 2;
+  }
+  if (!rosterJobKey(job)) {
+    console.error(rosterJobNameError(job));
+    return 2;
+  }
+  const switches = ['--everywhere', '--session', '--clear', '--add'];
+  const everywhere = args.includes('--everywhere');
+  const session = args.includes('--session');
+  const clear = args.includes('--clear');
+  const add = args.includes('--add');
+  const rest = args.slice(1).filter((arg) => !switches.includes(arg));
+  // The tool may be several words: claude code, atris fast.
+  const toolWords = [];
+  while (rest.length && !rest[0].startsWith('--')) toolWords.push(rest.shift());
+  const engine = toolWords.join(' ');
+  const flags = {};
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (!['--model', '--backup', '--days', '--like', '--effort', '--max', '--remove'].includes(arg) || !rest[i + 1] || rest[i + 1].startsWith('--')) {
+      console.error(`invalid assign option "${arg}"`);
+      return 2;
+    }
+    flags[arg.slice(2)] = rest[++i];
+  }
+  const removing = flags.remove !== undefined;
+  if (clear && (engine || Object.keys(flags).length || add)) {
+    console.error('use --clear without an engine or other options');
+    return 2;
+  }
+  if (removing && (engine || Object.keys(flags).length > 1 || add)) {
+    console.error('use --remove <tool> without other options');
+    return 2;
+  }
+  if (!clear && !removing && !engine) {
+    console.error(ASSIGN_USAGE);
+    return 2;
+  }
+  try {
+    setRosterPick(job, engine, { ...flags, clear, add, session, everywhere, now }, root);
+    printJobRoster(root, now);
+    return 0;
+  } catch (err) {
+    console.error(err.message);
+    return 2;
+  }
+}
+
 function chartEngineLabel(engine) {
   const id = String(engine && (engine.id || engine.name) || '').trim();
   const models = Array.isArray(engine && engine.models)
@@ -1104,14 +1460,22 @@ function runResolveCommand(args, root) {
   const json = args.includes('--json');
   const role = args.filter((a) => !String(a).startsWith('--'))[0] || '';
   if (!role) {
-    const message = `usage: atris engine resolve <role>; roles: ${ENGINE_ROLES.join(', ')}`;
+    const message = `usage: atris engine resolve <role> or <job>; roles: ${ENGINE_ROLES.join(', ')}; jobs: search, build, review, or your own`;
     if (json) console.log(JSON.stringify({ ok: false, error: message }, null, 2));
     else console.error(message);
     return 2;
   }
   let picked;
   try {
-    picked = resolveEngineForRoleRanked(role, root);
+    // A role (navigator, executor, validator) resolves as before; any job
+    // name, built-in or the owner's own, resolves through its roster pick.
+    const jobRole = ENGINE_ROLES.includes(String(role).trim().toLowerCase()) ? '' : rosterJobRole(role, root);
+    if (!ENGINE_ROLES.includes(String(role).trim().toLowerCase()) && !jobRole) {
+      throw new Error(`Unknown role "${role}". Known roles: ${ENGINE_ROLES.join(', ')}; jobs: search, build, review, or one set with atris engine assign`);
+    }
+    picked = jobRole
+      ? resolveEngineForRoleRanked(jobRole, root, { job: role })
+      : resolveEngineForRoleRanked(role, root);
   } catch (err) {
     if (json) console.log(JSON.stringify({ ok: false, error: err.message }, null, 2));
     else console.error(err.message);
@@ -1578,7 +1942,20 @@ function runDispatchCommand(args, root) {
       : `engine dispatch: ${err.message}`);
     return 2;
   }
-  return runDispatchFlight({ root, taskIds, engine: canonical, prompt: promptOverride, yolo, ...(base ? { checkoutBase: base } : {}) }).then((flight) => {
+  // The build line's model, effort, and time cap ride along when the roster
+  // picks this same engine for build.
+  const pin = rosterPinFor('executor', canonical, root);
+  return runDispatchFlight({
+    root,
+    taskIds,
+    engine: canonical,
+    prompt: promptOverride,
+    yolo,
+    ...(base ? { checkoutBase: base } : {}),
+    ...(pin.roster_model ? { model: pin.roster_model } : {}),
+    ...(pin.roster_effort ? { effort: pin.roster_effort } : {}),
+    ...(pin.roster_max_seconds ? { maxSeconds: pin.roster_max_seconds } : {}),
+  }).then((flight) => {
     if (json) console.log(JSON.stringify(flight, null, 2));
     return flight.paused.length ? 1 : 0;
   });
@@ -1657,6 +2034,9 @@ function engineCommand(args = [], deps = {}) {
   const positional = scope.args.filter((a) => !a.startsWith('--'));
   const sub = (positional[0] || '').trim();
 
+  if (sub === 'roster') return runRosterCommand(scope.args.slice(scope.args.indexOf('roster') + 1), root, deps.now);
+  if (sub === 'assign') return runAssignCommand(scope.args.slice(scope.args.indexOf('assign') + 1), root, deps.now);
+
   if (sub === 'login') {
     return runEngineLoginCommand(scope.args.slice(scope.args.indexOf('login') + 1), root);
   }
@@ -1705,7 +2085,7 @@ function engineCommand(args = [], deps = {}) {
     if (sub === 'help' || args.includes('--help') || args.includes('-h')) {
       console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
       console.log('\n  long read-only asks: atris engine ask "..." --engine agy --timeout <seconds>\n                           quick asks default to 120 seconds; explicit jobs allow up to 3600\n                           follow live work with atris engine watch latest');
-      console.log('\n  atris engine            roster + current default\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> [--json]\n                           choose the best ready engine for navigator|executor|validator\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
       return 0;
     }
     if (isFreshWorkspace(root)) {

package/commands/experiments.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { BACKEND_ROOT_HINT, resolveBackendRoot } = require('../utils/backend-root');
 const { runTaskOnce } = require('./autopilot');
 const {
   appendResultsRow,
@@ -391,7 +392,7 @@ function parseRunOptions(args) {
   const options = {
     dryRun: false,
     verbose: false,
-    backendPath: path.resolve(process.cwd(), '../atrisos-backend'),
+    backendPath: null,
     interventions: [],
   };
 
@@ -527,8 +528,10 @@ function buildBenchmarkArtifact(name, packDir, options) {
             'atris/features/endstate/contract.md',
             'atris/features/endstate/artifact-schema.json',
             path.relative(cwd, path.join(packDir, 'program.md')),
-            '../atrisos-backend/atris/MAP.md',
-            '../atrisos-backend/atris/TODO.md',
+            ...(backendPath ? [
+              path.relative(cwd, path.join(backendPath, 'atris', 'MAP.md')),
+              path.relative(cwd, path.join(backendPath, 'atris', 'TODO.md')),
+            ] : []),
           ],
           contextNote: [
             `Project Endstate track: ${track}`,
@@ -555,7 +558,7 @@ function buildBenchmarkArtifact(name, packDir, options) {
     ? []
     : [
         ...collectChangedFiles(cwd, beforeCli, afterCli),
-        ...collectChangedFiles(backendPath, beforeBackend, afterBackend, '../atrisos-backend/'),
+        ...(backendPath ? collectChangedFiles(backendPath, beforeBackend, afterBackend, `${path.relative(cwd, backendPath)}/`) : []),
       ];
   const wikiAfter = readTextIfExists(path.join(cwd, 'atris', 'wiki', 'STATUS.md'));
 
@@ -637,6 +640,12 @@ function experimentsRun(name, ...args) {
     return;
   }
 
+  if (!options.backendPath) options.backendPath = resolveBackendRoot();
+  if (!options.backendPath) {
+    console.error(BACKEND_ROOT_HINT);
+    process.exit(1);
+  }
+
   const schemaPath = path.join(process.cwd(), 'atris', 'features', 'endstate', 'artifact-schema.json');
   const contractPath = path.join(process.cwd(), 'atris', 'features', 'endstate', 'contract.md');
   if (!fs.existsSync(schemaPath) || !fs.existsSync(contractPath)) {

package/commands/host.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { hostAction } = require('../lib/host');
+
+function parse(argv) {
+  const options = {};
+  const positionals = [];
+  const flags = new Set(['id', 'name', 'team', 'manager', 'door', 'now', 'question', 'event-id', 'from', 'text', 'patch', 'expected-revision', 'source', 'evidence', 'reason', 'activity', 'as']);
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = argv[i];
+    if (item === '--json') { options.json = true; continue; }
+    if (item.startsWith('--')) {
+      const key = item.slice(2);
+      if (!flags.has(key) || !argv[i + 1] || argv[i + 1].startsWith('--')) throw new Error(`invalid --${key} value`);
+      options[key.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = argv[++i];
+    } else positionals.push(item);
+  }
+  return { options, positionals };
+}
+
+function human(command, result) {
+  if (command === 'room') return result.text;
+  if (command === 'due') return result.length ? result.map((entry) => `${entry.name} (${entry.id}) is due for a question.`).join('\n') : 'no questions due';
+  if (command === 'outbox') return result.length ? result.map((entry) => `${entry.id} ${entry.kind} to ${entry.to}: ${entry.text}`).join('\n') : 'outbox empty';
+  if (command === 'view') return [...result.cards.map((entry) => entry.card), result.own ? `Your private record:\n${JSON.stringify(result.own, null, 2)}` : ''].filter(Boolean).join('\n');
+  if (command === 'receive') return result.duplicate ? 'event already recorded' : `${result.kind} recorded for ${result.id}`;
+  return `${command} complete: ${JSON.stringify(result)}`;
+}
+
+function hostCommand(argv = process.argv.slice(3), root = process.cwd()) {
+  let jsonOutput = argv.includes('--json');
+  try {
+    const [command, ...rest] = argv;
+    if (!command || command === '--help' || command === '-h') {
+      const usage = 'usage: atris host join|leave|pause|resume|forget|due|ask|receive|card|link|propose|outbox|sent|room|view [options]';
+      console.log(jsonOutput ? JSON.stringify({ usage }) : usage);
+      return;
+    }
+    const { options, positionals } = parse(rest);
+    jsonOutput = options.json;
+    const args = { ...options };
+    if (['leave', 'pause', 'resume', 'forget', 'ask', 'card', 'sent'].includes(command)) args.id = positionals[0];
+    if (['link', 'propose'].includes(command)) { args.a = positionals[0]; args.b = positionals[1]; }
+    if (command === 'receive') args.eventId = options.eventId;
+    const result = hostAction(root, command, args);
+    console.log(jsonOutput ? JSON.stringify(result) : human(command, result));
+  } catch (error) {
+    console.error(jsonOutput ? JSON.stringify({ error: error.message }) : `host: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { hostCommand };

package/commands/improve.js

@@ -37,7 +37,7 @@ const rsi = require('../lib/rsi-record');
  * writes. The path sent to the backend is left untouched, a remote tick
  * may target a server-side `~/...` workspace the server expands itself, but
  * local scorecard/journal writes must never create a literal `~` directory.
- * (Surfaced by a live plan tick whose `~/arena/...` arg wrote junk locally.)
+ * (Surfaced by a live plan tick whose home-relative path wrote junk locally.)
  */
 function expandHome(p) {
   if (typeof p === 'string' && (p === '~' || p.startsWith('~/'))) {

package/commands/integrations.js

@@ -35,6 +35,7 @@ const os = require('os');
 const path = require('path');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
+const { sleepSync } = require('../lib/sleep-sync');
 
 const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
 const GMAIL_CONNECT_POLL_MS = 3000;
@@ -1812,10 +1813,6 @@ function writeImessageLookupCache(cache) {
   return cachePath;
 }
 
-function sleepMs(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
 function readLatestOutgoingImessage(handle, sinceMs) {
   const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
   const sinceUnix = Math.max(0, Math.floor(Number(sinceMs || Date.now()) / 1000) - 5);
@@ -1873,7 +1870,7 @@ function imessageVerifyLatestOutgoing(handle, sinceMs, options = {}) {
     && !(latest.is_sent || latest.is_delivered || latest.is_finished)
     && Date.now() - startedAt < timeoutMs
   ) {
-    sleepMs(intervalMs);
+    sleepSync(intervalMs);
     latest = readLatestOutgoingImessage(handle, sinceMs);
   }
   return {

package/commands/learn.js

@@ -460,7 +460,7 @@ function harvestFromJournals(deps = {}) {
       const lines = notesMatch[1].trim().split('\n').filter(l => l.startsWith('- '));
       for (const line of lines) {
         // Strip bullet and optional timestamp prefix
-        const insight = line.replace(/^- (\d{2}:\d{2} \u2014 )?/, '').trim();
+        const insight = line.replace(/^- (\d{2}:\d{2} [-\u2014] )?/, '').trim();
         if (leftoverClaimableInsight(insight)) continue;
         if (insight.length > 10) {
           candidates.push({ insight, source: path.basename(logPath) });