atris 3.38.0 → 3.41.0

package/commands/decide.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const {
+  answerMissionHumanAsk,
+  listMissions,
+  listWorktreeRollupMissions,
+  pingMission,
+} = require('./mission');
+const { openHumanAsks, normalizeHumanAsks } = require('../lib/mission-human-asks');
+const { redirectToWorkspaceRoot } = require('../lib/mission-root');
+const { shortId } = require('../lib/short-name');
+
+const TERMINAL_STATUSES = new Set(['stopped', 'complete']);
+
+function missionTouchedAt(mission) {
+  return String(mission.updated_at || mission.created_at || '');
+}
+
+function liveMissions(root = process.cwd()) {
+  const seen = new Set();
+  return [...listMissions(root), ...listWorktreeRollupMissions(root)]
+    .filter((mission) => {
+      if (!mission || !mission.id || seen.has(mission.id) || TERMINAL_STATUSES.has(mission.status)) return false;
+      seen.add(mission.id);
+      return true;
+    })
+    .sort((left, right) => (
+      missionTouchedAt(right).localeCompare(missionTouchedAt(left))
+      || String(left.id).localeCompare(String(right.id))
+    ));
+}
+
+function collectOpenDecisions(root = process.cwd()) {
+  const decisions = [];
+  for (const mission of liveMissions(root)) {
+    const normalized = normalizeHumanAsks(mission.human_asks);
+    normalized.forEach((ask, askIndex) => {
+      if (!ask.text.trim() || ask.answered_at) return;
+      decisions.push({
+        number: decisions.length + 1,
+        owner: String(mission.owner || 'unowned'),
+        mission_id: mission.id,
+        mission_short_id: shortId(mission.id),
+        mission_status: mission.status,
+        mission_updated_at: missionTouchedAt(mission),
+        ask_index: askIndex,
+        text: ask.text,
+      });
+    });
+  }
+  return decisions;
+}
+
+function printHelp() {
+  console.log('Usage:');
+  console.log('  atris decide');
+  console.log('  atris decide <n> y|n|yes|no [--note "<text>"]');
+  console.log('  atris decide --json');
+  console.log('  atris decide <n> y --json');
+}
+
+function fail(message, asJson, code = 2) {
+  if (asJson) {
+    console.log(JSON.stringify({ ok: false, action: 'decide_error', error: message }));
+  } else {
+    console.error(message);
+  }
+  process.exitCode = code;
+}
+
+function parseArgs(args) {
+  const asJson = args.includes('--json');
+  const rest = args.filter((arg) => arg !== '--json');
+  let note = '';
+  const noteIndex = rest.findIndex((arg) => arg === '--note' || String(arg).startsWith('--note='));
+  if (noteIndex !== -1) {
+    const noteArg = String(rest[noteIndex]);
+    if (noteArg === '--note') {
+      if (rest[noteIndex + 1] == null) return { asJson, error: '--note requires text' };
+      note = String(rest[noteIndex + 1]).trim();
+      rest.splice(noteIndex, 2);
+    } else {
+      note = noteArg.slice('--note='.length).trim();
+      rest.splice(noteIndex, 1);
+    }
+  }
+  return { asJson, note, rest };
+}
+
+function decideCommand(args = []) {
+  redirectToWorkspaceRoot();
+  const parsed = parseArgs(args);
+  if (parsed.error) return fail(parsed.error, parsed.asJson);
+  const { asJson, note, rest } = parsed;
+  if (rest.includes('--help') || rest.includes('-h') || rest[0] === 'help') {
+    printHelp();
+    return;
+  }
+
+  const decisions = collectOpenDecisions();
+  if (!rest.length) {
+    if (asJson) {
+      console.log(JSON.stringify({
+        ok: true,
+        action: 'decide_list',
+        count: decisions.length,
+        decisions,
+      }, null, 2));
+    } else if (!decisions.length) {
+      console.log('nothing is waiting for a decision.');
+    } else {
+      for (const decision of decisions) {
+        console.log(`[${decision.number}] ${decision.owner} · ${decision.mission_short_id} · ${decision.text}`);
+      }
+      console.log('atris decide <n> y|n');
+    }
+    return;
+  }
+
+  if (rest.length !== 2) {
+    return fail('usage: atris decide <n> y|n|yes|no [--note "<text>"]', asJson);
+  }
+  const number = Number(rest[0]);
+  if (!Number.isInteger(number) || number < 1) {
+    return fail('decision number must be a positive integer', asJson);
+  }
+  const answerToken = String(rest[1]).toLowerCase();
+  const answer = answerToken === 'y' || answerToken === 'yes'
+    ? 'yes'
+    : (answerToken === 'n' || answerToken === 'no' ? 'no' : null);
+  if (!answer) return fail('answer must be y, n, yes, or no', asJson);
+  const decision = decisions[number - 1];
+  if (!decision) return fail(`decision ${number} is not open`, asJson, 1);
+
+  const message = `Decision on "${decision.text}": ${answer.toUpperCase()}${note ? ` — ${note}` : ''}`;
+  pingMission([decision.mission_id, message, '--from', 'decide'], { silent: true });
+  const mission = answerMissionHumanAsk(decision.mission_id, decision.ask_index, answer, note);
+  const remainingOpenAsks = openHumanAsks(mission.human_asks).length;
+  const payload = {
+    ok: true,
+    action: 'decision_answered',
+    decision: {
+      ...decision,
+      answer,
+      note,
+      message,
+    },
+    mission: {
+      id: mission.id,
+      short_id: decision.mission_short_id,
+      owner: mission.owner,
+      status: mission.status,
+      remaining_open_asks: remainingOpenAsks,
+    },
+  };
+  if (asJson) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`sent to ${decision.mission_short_id}: ${message}`);
+    console.log(`mission ${decision.mission_short_id} will read it on its next tick.`);
+  }
+}
+
+module.exports = {
+  decideCommand,
+};

package/commands/deck.js

@@ -17,6 +17,7 @@ const fs = require('fs');
 const https = require('https');
 const os = require('os');
 const path = require('path');
+const { hasFlag } = require('../lib/arg-parser');
 const { buildDeck, THEMES, notesRequests } = require('../lib/slides-deck');
 const {
   lintSpec,
@@ -118,10 +119,6 @@ function flag(argv, name) {
   return i !== -1 ? argv[i + 1] : null;
 }
 
-function hasFlag(argv, name) {
-  return argv.includes(name);
-}
-
 // Flags that take a value, so their following token is consumed (not a path).
 const VALUE_FLAGS = new Set(['--theme', '--title', '--update', '--out', '--style', '--url', '--md']);
 

package/commands/drill.js

@@ -3,22 +3,12 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const { hasFlag } = require('../lib/arg-parser');
+const { runGit } = require('../lib/git-spawn');
 
 const VERIFY_COMMAND = 'node -e "process.exit(0)"';
 const COAUTHOR = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
-function runGit(args, cwd, options = {}) {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
-  if (options.check === false || result.status === 0) return result;
-  const output = (result.stderr || result.stdout || `git ${args.join(' ')} failed`).trim();
-  throw new Error(output);
-}
-
 function parseJsonOutput(text) {
   const raw = String(text || '').trim();
   if (!raw) throw new Error('expected JSON output, got empty output');
@@ -97,9 +87,9 @@ async function createSandbox(ctx) {
   ctx.tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-drill-'));
   ctx.sandboxPath = path.join(ctx.tmpRoot, 'sandbox');
   fs.mkdirSync(ctx.sandboxPath, { recursive: true });
-  runGit(['init', '-b', 'master'], ctx.sandboxPath);
-  runGit(['config', 'user.email', 'drill@example.invalid'], ctx.sandboxPath);
-  runGit(['config', 'user.name', 'Atris Drill'], ctx.sandboxPath);
+  runGit(['init', '-b', 'master'], { cwd: ctx.sandboxPath });
+  runGit(['config', 'user.email', 'drill@example.invalid'], { cwd: ctx.sandboxPath });
+  runGit(['config', 'user.name', 'Atris Drill'], { cwd: ctx.sandboxPath });
   fs.writeFileSync(path.join(ctx.sandboxPath, 'README.md'), '# Atris drill sandbox\n', 'utf8');
   await withSandboxProcessState(ctx.sandboxPath, {
     ATRIS_SKIP_UPDATE_CHECK: '1',
@@ -108,8 +98,8 @@ async function createSandbox(ctx) {
   }, async () => {
     await callInitAtris(ctx.sandboxPath);
   });
-  runGit(['add', '-A'], ctx.sandboxPath);
-  runGit(['commit', '-m', 'initial sandbox'], ctx.sandboxPath);
+  runGit(['add', '-A'], { cwd: ctx.sandboxPath });
+  runGit(['commit', '-m', 'initial sandbox'], { cwd: ctx.sandboxPath });
 }
 
 async function wishCaptured(ctx) {
@@ -199,10 +189,10 @@ async function landingShippedLocal(ctx) {
   try {
     require('../lib/task-db').close();
   } catch {}
-  const dirty = runGit(['status', '--porcelain'], ctx.sandboxPath).stdout.trim();
+  const dirty = runGit(['status', '--porcelain'], { cwd: ctx.sandboxPath }).stdout.trim();
   if (dirty) {
-    runGit(['add', '-A'], ctx.sandboxPath);
-    runGit(['commit', '-m', 'record drill pipeline state'], ctx.sandboxPath);
+    runGit(['add', '-A'], { cwd: ctx.sandboxPath });
+    runGit(['commit', '-m', 'record drill pipeline state'], { cwd: ctx.sandboxPath });
   }
   ctx.landingWorktree = path.join(ctx.tmpRoot, 'landing-worktree');
   const created = worktree.createAgentWorktree({
@@ -229,9 +219,9 @@ async function landingShippedLocal(ctx) {
     assertOk(shipped.value === 0, `worktree ship exited ${shipped.value}`);
     assertOk(/local mode/.test(`${shipped.stdout}\n${shipped.stderr}`), 'worktree ship did not report local mode');
   });
-  runGit(['worktree', 'remove', ctx.landingWorktree, '--force'], ctx.sandboxPath);
-  runGit(['branch', '-d', ctx.landingBranch], ctx.sandboxPath);
-  const landed = runGit(['show', 'master:drill-landing.txt'], ctx.sandboxPath).stdout;
+  runGit(['worktree', 'remove', ctx.landingWorktree, '--force'], { cwd: ctx.sandboxPath });
+  runGit(['branch', '-d', ctx.landingBranch], { cwd: ctx.sandboxPath });
+  const landed = runGit(['show', 'master:drill-landing.txt'], { cwd: ctx.sandboxPath }).stdout;
   assertOk(landed.trim() === 'local landing ok', 'landing file was not merged into sandbox master');
 }
 
@@ -244,7 +234,7 @@ async function ledgerChecked(ctx) {
   assertOk(currentMission, `mission not found: ${ctx.missionId}`);
   assertOk(currentMission.verifier_result && currentMission.verifier_result.passed === true, 'mission verifier result is not passing');
   assertOk(currentMission.receipt_path && fs.existsSync(path.join(ctx.sandboxPath, currentMission.receipt_path)), `mission receipt missing: ${currentMission.receipt_path}`);
-  const unmerged = runGit(['branch', '--no-merged', 'master'], ctx.sandboxPath).stdout
+  const unmerged = runGit(['branch', '--no-merged', 'master'], { cwd: ctx.sandboxPath }).stdout
     .split(/\r?\n/)
     .map((line) => line.replace(/^\*/, '').trim())
     .filter(Boolean)

package/commands/engine.js

@@ -26,6 +26,7 @@ const {
 } = require('../lib/runner-command');
 const {
   ENGINE_ROLES,
+  ENGINE_DUTIES,
   ENGINE_HEALTH_STATUSES,
   binInstalled,
   canonicalEngineName,
@@ -34,6 +35,9 @@ const {
   readEngineRegistry,
   resolveEngineForRole,
   resolveEngineForRoleRanked,
+  requireEngineBin,
+  engineDoctorReport,
+  setEngineOverrides,
   setEngineHealth,
 } = require('../lib/engine-registry');
 const { FLEET_CAPABLE, runDispatchFlight } = require('../lib/fleet');
@@ -90,14 +94,22 @@ function readSavedEngine(root = process.cwd()) {
 
 // The default engine for this workspace, in precedence order:
 // env (per-run flags land here) -> .atris/engine.json -> house default.
-// The house default is our own intelligence when it is installed.
+// When nothing is configured the pick comes from the registry's saved health
+// (seeded once on first sight, refreshed by `atris engine doctor`), never a
+// machine probe: policy over probes. A stale "ready" is the execution stage's
+// problem, where requireEngineBin fails in one plain sentence.
 function resolveDefaultEngine(root = process.cwd()) {
   const env = canonicalEngineName(process.env.ATRIS_RUNNER_PROFILE);
   if (env) return { name: env, source: 'env' };
   const saved = readSavedEngine(root);
   if (saved) return { name: saved, source: 'saved' };
-  if (binInstalled(RUNNER_PROFILE_DEFS[HOUSE_ENGINE].bin)) return { name: HOUSE_ENGINE, source: 'house' };
-  const fallback = RUNNER_PROFILE_NAMES.find((name) => binInstalled(RUNNER_PROFILE_DEFS[name].bin));
+  const ready = new Set(
+    engineRegistryView(root)
+      .filter((engine) => engine.health && engine.health.status === 'ready')
+      .map((engine) => engine.id)
+  );
+  if (ready.has(HOUSE_ENGINE)) return { name: HOUSE_ENGINE, source: 'house' };
+  const fallback = RUNNER_PROFILE_NAMES.find((name) => ready.has(name));
   return fallback ? { name: fallback, source: 'detected' } : { name: HOUSE_ENGINE, source: 'none' };
 }
 
@@ -887,13 +899,16 @@ function printRoster(root) {
   const found = list.filter((e) => e.installed).length;
   const current = resolveDefaultEngine(root);
   console.log('');
-  console.log(`  engines — ${found} intelligence${found === 1 ? '' : 's'} found`);
+  console.log(`  engines: ${found} intelligence${found === 1 ? '' : 's'} found`);
   console.log('');
   for (const engine of list) {
     const mark = engine.default ? '→' : ' ';
     const state = engine.health.status === 'not_installed' ? 'not installed' : engine.health.status.replace(/_/g, ' ');
     const roles = engine.roles.join(',');
     console.log(`  ${mark} ${engine.id.padEnd(12)} ${state.padEnd(13)} ${engine.tier.padEnd(4)} ${roles}`);
+    const details = [`models: ${engine.models.join(', ')}`];
+    if (engine.duty) details.push(`duty: ${engine.duty}`);
+    console.log(`      ${details.join('   ')}`);
   }
   console.log('');
   console.log(`  default: ${current.name}${current.source === 'saved' ? ' (set here)' : current.source === 'env' ? ' (this session)' : ''}`);
@@ -901,6 +916,139 @@ function printRoster(root) {
   console.log('');
 }
 
+function chartEngineLabel(engine) {
+  const id = String(engine && (engine.id || engine.name) || '').trim();
+  const models = Array.isArray(engine && engine.models)
+    ? engine.models.map((model) => String(model || '').trim()).filter(Boolean)
+    : [];
+  return models.length ? `${id}: ${models.join(', ')}` : id;
+}
+
+function chartBox(title, engines, note = '', emptyLabel = 'unassigned') {
+  const labels = engines.length ? engines.map(chartEngineLabel) : (emptyLabel ? [emptyLabel] : []);
+  const body = [title, ...labels, ...(note ? [note] : [])];
+  const innerWidth = Math.max(...body.map((line) => line.length)) + 2;
+  return {
+    width: innerWidth + 2,
+    lines: [
+      `┌${'─'.repeat(innerWidth)}┐`,
+      ...body.map((line) => `│ ${line.padEnd(innerWidth - 2)} │`),
+      `└${'─'.repeat(innerWidth)}┘`,
+    ],
+  };
+}
+
+function centerChartLine(line, width, center = Math.floor((width - 1) / 2)) {
+  const left = Math.max(0, center - Math.floor(line.length / 2));
+  return `${' '.repeat(left)}${line}`.padEnd(width);
+}
+
+function renderEngineChart(registry) {
+  const engines = Array.isArray(registry) ? registry : ((registry && registry.engines) || []);
+  const specialDuties = new Set(ENGINE_DUTIES);
+  const leaders = engines.filter((entry) => entry.duty === 'leader');
+  const rolePool = engines.filter((entry) => !specialDuties.has(entry.duty));
+  const builders = rolePool.filter((entry) => Array.isArray(entry.roles) && entry.roles.includes('executor'));
+  const checkers = rolePool.filter((entry) => Array.isArray(entry.roles) && entry.roles.includes('validator'));
+  const errands = engines.filter((entry) => entry.duty === 'errands');
+  const apprentices = engines.filter((entry) => entry.duty === 'learning');
+
+  const ownerBox = chartBox('owner', [], '', '');
+  const leaderBox = chartBox('leader', leaders);
+  const columns = [
+    chartBox('builders', builders),
+    chartBox('checkers', checkers),
+    chartBox('errands', errands),
+  ];
+  const gap = 3;
+  const totalWidth = columns.reduce((sum, column) => sum + column.width, 0) + (gap * (columns.length - 1));
+  const columnHeight = Math.max(...columns.map((column) => column.lines.length));
+  const columnLines = [];
+  for (let row = 0; row < columnHeight; row += 1) {
+    columnLines.push(columns.map((column) => (column.lines[row] || '').padEnd(column.width)).join(' '.repeat(gap)));
+  }
+
+  const centers = [];
+  let offset = 0;
+  for (const column of columns) {
+    centers.push(offset + Math.floor(column.width / 2));
+    offset += column.width + gap;
+  }
+  const fleetCenter = centers[1];
+  const branch = Array(totalWidth).fill(' ');
+  for (let i = centers[0]; i <= centers[centers.length - 1]; i += 1) branch[i] = '─';
+  branch[centers[0]] = '┌';
+  branch[centers[centers.length - 1]] = '┐';
+  for (const center of centers.slice(1, -1)) branch[center] = '┬';
+  branch[fleetCenter] = centers.includes(fleetCenter) ? '┼' : '┴';
+  const stems = Array(totalWidth).fill(' ');
+  for (const center of centers) stems[center] = '│';
+
+  const lines = [
+    ...ownerBox.lines.map((line) => centerChartLine(line, totalWidth, fleetCenter)),
+    centerChartLine('│', totalWidth, fleetCenter),
+    ...leaderBox.lines.map((line) => centerChartLine(line, totalWidth, fleetCenter)),
+    centerChartLine('│', totalWidth, fleetCenter),
+    branch.join(''),
+    stems.join(''),
+    ...columnLines,
+  ];
+  if (apprentices.length) {
+    const apprenticeBox = chartBox('apprentice', apprentices, 'learning the system');
+    lines.push(centerChartLine('│', totalWidth, fleetCenter));
+    lines.push(...apprenticeBox.lines.map((line) => centerChartLine(line, totalWidth, fleetCenter)));
+  }
+  return lines.map((line) => line.replace(/\s+$/, '')).join('\n');
+}
+
+function printEngineChart(root) {
+  console.log(renderEngineChart(readEngineRegistry(root)));
+}
+
+function flagValue(args, flag) {
+  const equals = `${flag}=`;
+  for (let i = 0; i < args.length; i += 1) {
+    const value = String(args[i] || '');
+    if (value === flag) return { present: true, value: args[i + 1] || '' };
+    if (value.startsWith(equals)) return { present: true, value: value.slice(equals.length) };
+  }
+  return { present: false, value: '' };
+}
+
+function runSetEngineCommand(args, root) {
+  const name = String(args[0] || '').trim();
+  const dutyFlag = flagValue(args.slice(1), '--duty');
+  const modelsFlag = flagValue(args.slice(1), '--models');
+  const duty = String(dutyFlag.value || '').trim();
+  const models = String(modelsFlag.value || '').split(',').map((model) => model.trim()).filter(Boolean);
+  if (!name || (!dutyFlag.present && !modelsFlag.present)) {
+    console.error('usage: atris engine set <name> [--duty leader|errands|learning] [--models "a, b"]');
+    return 2;
+  }
+  if (dutyFlag.present && !ENGINE_DUTIES.includes(duty)) {
+    console.error(`unknown duty "${duty}". known duties: ${ENGINE_DUTIES.join(', ')}`);
+    return 2;
+  }
+  if (modelsFlag.present && !models.length) {
+    console.error('models must include at least one name');
+    return 2;
+  }
+  try {
+    const updated = setEngineOverrides(name, {
+      ...(dutyFlag.present ? { duty } : {}),
+      ...(modelsFlag.present ? { models } : {}),
+    }, root);
+    const details = [];
+    if (updated.duty) details.push(`duty ${updated.duty}`);
+    if (updated.models) details.push(`models ${updated.models.join(', ')}`);
+    console.log(`${updated.id} updated: ${details.join('; ')}`);
+    return 0;
+  } catch (err) {
+    console.error(String(err.message || err).replace(/^Unknown/, 'unknown'));
+    return 2;
+  }
+}
+
 function registryPayload(root) {
   const current = resolveDefaultEngine(root);
   const registry = readEngineRegistry(root);
@@ -956,6 +1104,28 @@ function runResolveCommand(args, root) {
   return 0;
 }
 
+// Doctor is the one opt-in place that probes the machine: it checks every
+// engine binary, reports installed state, and folds ready/not_installed flips
+// back into the policy file. Routing itself never probes.
+function runDoctorCommand(args, root) {
+  const json = args.includes('--json');
+  const engines = engineDoctorReport(root);
+  if (json) {
+    console.log(JSON.stringify({ ok: true, engines }, null, 2));
+    return 0;
+  }
+  console.log('');
+  for (const engine of engines) {
+    const state = engine.installed ? 'installed' : 'missing';
+    const health = engine.health.status.replace(/_/g, ' ');
+    console.log(`  ${engine.id.padEnd(12)} ${String(engine.bin).padEnd(14)} ${state.padEnd(10)} health: ${health}`);
+  }
+  console.log('');
+  console.log('  probed just now and saved to the registry; routing reads that saved policy, never the machine.');
+  console.log('');
+  return 0;
+}
+
 function runHealthCommand(args, root) {
   const json = args.includes('--json');
   const positional = args.filter((a) => !String(a).startsWith('--'));
@@ -1203,9 +1373,12 @@ function runDispatchCommand(args, root) {
       return 2;
     }
   }
-  const def = RUNNER_PROFILE_DEFS[canonical];
-  if (!binInstalled(def.bin)) {
-    console.error(`engine dispatch: ${canonical} CLI (${def.bin}) is not installed here`);
+  // Execution stage: this is where the binary must exist. Routing above never
+  // probed the machine; a missing CLI fails loudly here instead.
+  try {
+    requireEngineBin(canonical);
+  } catch (err) {
+    console.error(`engine dispatch: ${err.message}`);
     return 2;
   }
   return runDispatchFlight({ root, taskIds, engine: canonical, prompt: promptOverride, yolo, ...(base ? { checkoutBase: base } : {}) }).then((flight) => {
@@ -1248,6 +1421,19 @@ function engineCommand(args = [], deps = {}) {
     return runHealthCommand(args.slice(args.indexOf('health') + 1), root);
   }
 
+  if (sub === 'doctor') {
+    return runDoctorCommand(args.slice(args.indexOf('doctor') + 1), root);
+  }
+
+  if (sub === 'set') {
+    return runSetEngineCommand(args.slice(args.indexOf('set') + 1), root);
+  }
+
+  if (sub === 'chart' || args.includes('--chart')) {
+    printEngineChart(root);
+    return 0;
+  }
+
   if (!sub || sub === 'list' || sub === 'status') {
     if (json) {
       console.log(JSON.stringify(registryPayload(root), null, 2));
@@ -1266,7 +1452,7 @@ function engineCommand(args = [], deps = {}) {
   }
 
   if (sub === 'help') {
-    console.log('\n  atris engine            roster + current default\n  atris engine list --json full registry: default + engines with tier, roles, fallback, health\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 <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\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 engines --chart   show the fleet as an org chart\n  atris engine list --json full registry: default + engines with tier, roles, fallback, health\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 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;
   }
 
@@ -1304,6 +1490,8 @@ module.exports = {
   readEngineRegistry,
   resolveEngineForRole,
   setEngineHealth,
+  setEngineOverrides,
+  renderEngineChart,
   parseDispatchArgs,
   runDispatchCommand,
   ENGINE_LOGIN_MANIFESTS,

package/commands/gm.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
 const AGENTXP_GLOBAL_SYNC_RULE = 'Run atris login, then sync. Owner-provided sync tokens are guided-demo fallback only.';
@@ -54,8 +55,9 @@ function flag(args, name) {
   return null;
 }
 
-function hasFlag(args, name) {
-  return args.includes(name) || args.some(arg => arg.startsWith(`${name}=`));
+// This command treats --name=value as flag presence as well as a standalone flag.
+function hasFlagOrValue(args, name) {
+  return hasExactFlag(args, name) || args.some(arg => arg.startsWith(`${name}=`));
 }
 
 function positional(args) {
@@ -185,7 +187,7 @@ function pickSeedPlayer(workspaceRoot, tasks, args = []) {
 }
 
 function ensureStarterMission(taskDb, db, workspaceRoot, tasks, args = []) {
-  if (hasFlag(args, '--no-seed')) return { tasks, seeded: null };
+  if (hasFlagOrValue(args, '--no-seed')) return { tasks, seeded: null };
   if (!fs.existsSync(path.join(workspaceRoot, 'atris'))) return { tasks, seeded: null };
   if (activeAgentXpTasks(tasks).length) return { tasks, seeded: null };
 
@@ -658,7 +660,7 @@ async function gmCommand(...args) {
     return memberCommand('wake', member, ...passthrough);
   }
 
-  if (!hasFlag(args, '--json') && !hasFlag(args, '--watch')) {
+  if (!hasFlagOrValue(args, '--json') && !hasFlagOrValue(args, '--watch')) {
     try {
       const { gameCommand } = require('./game');
       const dashboardShown = await gameCommand([], { silentMissing: true });
@@ -669,12 +671,12 @@ async function gmCommand(...args) {
   }
 
   const state = gmState(args);
-  if (hasFlag(args, '--json')) {
+  if (hasFlagOrValue(args, '--json')) {
     console.log(JSON.stringify(state, null, 2));
     return;
   }
   render(state);
-  if (hasFlag(args, '--watch')) {
+  if (hasFlagOrValue(args, '--watch')) {
     await gmWatch(args);
   }
 }

package/commands/harvest.js

@@ -1,14 +1,11 @@
 const fs = require('fs');
 const path = require('path');
+const { hasFlag } = require('../lib/arg-parser');
 const {
   isGenericInboxPlaceholder,
   seedInboxFromMove,
 } = require('../lib/next-moves');
 
-function hasFlag(args, name) {
-  return args.includes(name);
-}
-
 function safeRead(file) {
   try { return fs.readFileSync(file, 'utf8'); } catch { return ''; }
 }