atris 3.42.0 → 3.44.0

package/commands/engine.js

@@ -41,6 +41,12 @@ const {
   setEngineHealth,
 } = require('../lib/engine-registry');
 const { FLEET_CAPABLE, runDispatchFlight } = require('../lib/fleet');
+const {
+  buildReadOnlyEngineInvocation,
+  runEngineAskCommand,
+} = require('../lib/engine-ask');
+const { runEngineValidateCommand } = require('../lib/engine-validate');
+const { runEngineWatchCommand } = require('./engine-watch');
 const { ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 
@@ -895,6 +901,7 @@ async function runEngineSeedCommand(args, root, deps = {}) {
 }
 
 function printRoster(root) {
+  reconcileStaleEngineProbeErrors(root);
   const list = roster(root);
   const found = list.filter((e) => e.installed).length;
   const current = resolveDefaultEngine(root);
@@ -1104,12 +1111,34 @@ function runResolveCommand(args, root) {
   return 0;
 }
 
+// Doctor and roster both read saved health; when a probe once failed but the
+// binary is present again, clear stale error so routing is not stuck forever.
+function reconcileStaleEngineProbeErrors(root = process.cwd()) {
+  for (const engine of engineRegistryView(root)) {
+    const status = engine.health && engine.health.status;
+    if (status !== 'error') continue;
+    if (!binInstalled(engine.bin)) continue;
+    try { setEngineHealth(engine.id, 'ready', root); } catch { /* best effort */ }
+  }
+}
+
 // 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);
+  reconcileStaleEngineProbeErrors(root);
+  const engines = engineDoctorReport(root).map((engine) => {
+    if (!engine.installed) return engine;
+    const status = engine.health && engine.health.status;
+    if (status !== 'error') return engine;
+    try {
+      const updated = setEngineHealth(engine.id, 'ready', root);
+      return { ...engine, health: updated.health };
+    } catch {
+      return engine;
+    }
+  });
   if (json) {
     console.log(JSON.stringify({ ok: true, engines }, null, 2));
     return 0;
@@ -1387,10 +1416,72 @@ function runDispatchCommand(args, root) {
   });
 }
 
+const TASK_ID_TOKEN = /^[a-z][a-z0-9]*-\d+$/i;
+const SHORTHAND_VALUE_FLAGS = new Set(['--model', '--concurrency', '--timeout', '--jobs', '--engine', '--engines']);
+
+function shorthandPromptParts(args) {
+  const parts = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const value = String(args[index] || '');
+    if (SHORTHAND_VALUE_FLAGS.has(value)) {
+      index += 1;
+      continue;
+    }
+    if (value.startsWith('--')) continue;
+    parts.push(value);
+  }
+  return parts;
+}
+
+function shorthandModelError(engine, args, root) {
+  const requested = flagValue(args, '--model');
+  const model = String(requested.value || '').trim();
+  if (!requested.present || !model) return '';
+  try {
+    buildReadOnlyEngineInvocation(engine, 'check model support', model);
+    return '';
+  } catch (error) {
+    if (!error || error.reason !== 'model_not_supported') return '';
+    const examples = engineRegistryView(root).find((entry) => entry.id === engine)?.models || [];
+    const known = examples.length ? examples.join(', ') : 'use the engine default';
+    return `${error.message}. known-good ${engine} examples: ${known}`;
+  }
+}
+
 function engineCommand(args = [], deps = {}) {
-  const root = process.cwd();
+  const root = deps.root || process.cwd();
+  const dispatch = deps.engineDispatch || runDispatchCommand;
+  if ((args[0] || '').trim() === 'ask') {
+    return runEngineAskCommand(args.slice(1), root, deps.engineAsk || {});
+  }
+  if ((args[0] || '').trim() === 'watch') {
+    return runEngineWatchCommand(args.slice(1), root, deps.engineWatch || {});
+  }
+  if ((args[0] || '').trim() === 'validate') {
+    return runEngineValidateCommand(args.slice(1), root, deps.engineValidate || {});
+  }
   if ((args[0] || '').trim() === 'dispatch') {
-    return runDispatchCommand(args.slice(1), root);
+    return dispatch(args.slice(1), root);
+  }
+
+  const requestedEngine = (args[0] || '').trim();
+  if (canonicalEngineName(requestedEngine) && args.length > 1) {
+    const canonical = canonicalEngineName(requestedEngine);
+    const shorthandArgs = args.slice(1);
+    const promptParts = shorthandPromptParts(shorthandArgs);
+    if (TASK_ID_TOKEN.test(promptParts[0] || '')) {
+      if (shorthandArgs.length !== 1) {
+        console.error('engine shorthand: a task id cannot include prompt text or flags; pick one: ask a question or build the task');
+        return 2;
+      }
+      return dispatch([promptParts[0], '--engine', canonical], root);
+    }
+    const modelError = shorthandModelError(canonical, shorthandArgs, root);
+    if (modelError) {
+      console.error(`engine ask: ${modelError}`);
+      return 2;
+    }
+    return runEngineAskCommand([...shorthandArgs, '--engine', canonical], root, deps.engineAsk || {});
   }
 
   const json = args.includes('--json');
@@ -1452,7 +1543,8 @@ function engineCommand(args = [], deps = {}) {
   }
 
   if (sub === 'help') {
-    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');
+    console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
+    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 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;
   }
 
@@ -1470,13 +1562,9 @@ function engineCommand(args = [], deps = {}) {
     return 2;
   }
   const canonical = setEngine(sub, root);
-  const def = RUNNER_PROFILE_DEFS[canonical];
-  const installed = binInstalled(def.bin);
-  console.log('');
-  console.log(`  default engine: ${canonical}`);
-  if (!installed) console.log(`  heads up: its CLI (${def.bin}) is not installed here yet — runs will fail until it is.`);
-  console.log(`  every mission run / autopilot / run tick now rides it. one-off: --engine <name>. undo: atris engine reset`);
-  console.log('');
+  console.log(`default engine changed to ${canonical}`);
+  console.log(`ask a question: atris engine ask "..." --engine ${canonical}`);
+  console.log(`dispatch a build: atris engine dispatch <task> --engine ${canonical}`);
   return 0;
 }
 

package/commands/founder.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_DAYS = 28;
+const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
+const SCORECARD_FILE = path.join('.atris', 'state', 'founder', 'scorecard.jsonl');
+
+function runGit(cwd, args) {
+  const run = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  return {
+    ok: !run.error && run.status === 0,
+    stdout: run.stdout || '',
+  };
+}
+
+function workspaceRoot(cwd = process.cwd()) {
+  const top = runGit(cwd, ['rev-parse', '--show-toplevel']);
+  return top.ok && top.stdout.trim() ? path.resolve(top.stdout.trim()) : path.resolve(cwd);
+}
+
+function defaultScanRoot(cwd, currentWorkspace) {
+  const commonDir = runGit(cwd, ['rev-parse', '--git-common-dir']);
+  if (commonDir.ok && commonDir.stdout.trim()) {
+    const absoluteCommonDir = path.resolve(cwd, commonDir.stdout.trim());
+    if (path.basename(absoluteCommonDir) === '.git') {
+      return path.dirname(path.dirname(absoluteCommonDir));
+    }
+  }
+  return path.dirname(currentWorkspace);
+}
+
+function parseArgs(args = []) {
+  let index = args[0] === 'score' ? 1 : 0;
+  let root = null;
+  let days = DEFAULT_DAYS;
+
+  while (index < args.length) {
+    const arg = String(args[index]);
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      return { help: true, root, days };
+    }
+    if (arg === '--root' || arg.startsWith('--root=')) {
+      const value = arg.startsWith('--root=') ? arg.slice('--root='.length) : args[++index];
+      if (!value || String(value).startsWith('--')) throw new Error('--root needs a directory.');
+      root = String(value);
+      index += 1;
+      continue;
+    }
+    if (arg === '--days' || arg.startsWith('--days=')) {
+      const value = arg.startsWith('--days=') ? arg.slice('--days='.length) : args[++index];
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 1) throw new Error('--days must be a positive integer.');
+      days = parsed;
+      index += 1;
+      continue;
+    }
+    throw new Error(`unknown founder option: ${arg}`);
+  }
+
+  return { help: false, root, days };
+}
+
+function founderNow(env = process.env) {
+  const raw = String(env.ATRIS_FOUNDER_NOW || '').trim();
+  const value = /^\d{4}-\d{2}-\d{2}$/.test(raw) ? `${raw}T23:59:59.999Z` : raw;
+  const now = value ? new Date(value) : new Date();
+  if (!Number.isFinite(now.getTime())) throw new Error('ATRIS_FOUNDER_NOW must be an ISO date.');
+  return now;
+}
+
+function utcDayStart(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+
+function dateKey(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (!Number.isFinite(date.getTime())) return null;
+  return date.toISOString().slice(0, 10);
+}
+
+function historyBounds(now, days) {
+  const today = utcDayStart(now);
+  const historyStart = new Date(today.getTime() - (days - 1) * DAY_MS);
+  const currentWindowStart = new Date(now.getTime() - 7 * DAY_MS);
+  const priorWindowStart = new Date(currentWindowStart.getTime() - 7 * DAY_MS);
+  return {
+    since: historyStart < priorWindowStart ? historyStart : priorWindowStart,
+    until: now,
+    currentWindowStart,
+    priorWindowStart,
+  };
+}
+
+function defaultBranch(repoRoot) {
+  const remoteHead = runGit(repoRoot, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD']);
+  if (remoteHead.ok && remoteHead.stdout.trim()) return remoteHead.stdout.trim();
+
+  for (const name of ['main', 'master']) {
+    if (runGit(repoRoot, ['show-ref', '--verify', '--quiet', `refs/heads/${name}`]).ok) return name;
+  }
+
+  const current = runGit(repoRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+  if (current.ok && current.stdout.trim()) return current.stdout.trim();
+  return runGit(repoRoot, ['rev-parse', '--verify', 'HEAD']).ok ? 'HEAD' : null;
+}
+
+function commitHistory(repoRoot, branch, bounds) {
+  if (!branch) return { perDay: {}, timestamps: [] };
+  const history = runGit(repoRoot, [
+    'log',
+    branch,
+    `--since=${bounds.since.toISOString()}`,
+    `--until=${bounds.until.toISOString()}`,
+    '--format=%cI',
+  ]);
+  if (!history.ok) return { perDay: {}, timestamps: [] };
+
+  const daily = {};
+  const timestamps = [];
+  for (const line of history.stdout.split('\n')) {
+    const timestamp = new Date(line.trim());
+    if (!Number.isFinite(timestamp.getTime())) continue;
+    timestamps.push(timestamp);
+    const day = dateKey(timestamp);
+    if (day) daily[day] = (daily[day] || 0) + 1;
+  }
+  return {
+    perDay: Object.fromEntries(Object.entries(daily).sort(([left], [right]) => left.localeCompare(right))),
+    timestamps,
+  };
+}
+
+function totalInRange(timestamps, start, end, includeEnd = false) {
+  const startTime = start.getTime();
+  const endTime = end.getTime();
+  return timestamps.reduce((total, timestamp) => {
+    const time = timestamp.getTime();
+    const inside = time >= startTime && (includeEnd ? time <= endTime : time < endTime);
+    return inside ? total + 1 : total;
+  }, 0);
+}
+
+function discoverRepos(root) {
+  return fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name !== '.agent-worktrees')
+    .map((entry) => path.join(root, entry.name))
+    .filter((repoRoot) => fs.existsSync(path.join(repoRoot, '.git')))
+    .sort((left, right) => path.basename(left).localeCompare(path.basename(right)));
+}
+
+function collectRepoScorecards(root, bounds) {
+  return discoverRepos(root).map((repoRoot) => {
+    const branch = defaultBranch(repoRoot);
+    const history = commitHistory(repoRoot, branch, bounds);
+    return {
+      repo: path.basename(repoRoot),
+      commitsThisWeek: totalInRange(history.timestamps, bounds.currentWindowStart, bounds.until, true),
+      commitsLastWeek: totalInRange(history.timestamps, bounds.priorWindowStart, bounds.currentWindowStart),
+      perDay: history.perDay,
+    };
+  }).sort((left, right) => (
+    right.commitsThisWeek - left.commitsThisWeek
+    || right.commitsLastWeek - left.commitsLastWeek
+    || left.repo.localeCompare(right.repo)
+  ));
+}
+
+function taskRows(parsed) {
+  if (Array.isArray(parsed)) return parsed;
+  return Array.isArray(parsed?.tasks) ? parsed.tasks : null;
+}
+
+function taskClosedAt(task) {
+  const direct = task?.done_at || task?.closed_at || task?.completed_at;
+  if (direct) return direct;
+  const events = Array.isArray(task?.events) ? [...task.events].reverse() : [];
+  const closedEvent = events.find((event) => {
+    const eventName = String(event?.event_type || event?.type || event?.status || '').toLowerCase();
+    return ['done', 'closed', 'completed'].includes(eventName);
+  });
+  return closedEvent?.created_at || closedEvent?.ts || null;
+}
+
+function readTaskScorecard(root, bounds) {
+  const file = path.join(root, TASK_PROJECTION_FILE);
+  if (!fs.existsSync(file)) return { available: false, thisWeek: null, lastWeek: null };
+
+  try {
+    const tasks = taskRows(JSON.parse(fs.readFileSync(file, 'utf8')));
+    if (!tasks) return { available: false, thisWeek: null, lastWeek: null };
+
+    const timestamps = [];
+    for (const task of tasks) {
+      const status = String(task?.status || '').trim().toLowerCase();
+      if (!['done', 'closed'].includes(status)) continue;
+      const timestamp = new Date(taskClosedAt(task));
+      if (Number.isFinite(timestamp.getTime())) timestamps.push(timestamp);
+    }
+
+    return {
+      available: true,
+      thisWeek: totalInRange(timestamps, bounds.currentWindowStart, bounds.until, true),
+      lastWeek: totalInRange(timestamps, bounds.priorWindowStart, bounds.currentWindowStart),
+    };
+  } catch {
+    return { available: false, thisWeek: null, lastWeek: null };
+  }
+}
+
+function percentChange(current, previous) {
+  if (previous === 0) return current === 0 ? 0 : 100;
+  return Math.round(((current - previous) / previous) * 100);
+}
+
+function buildFounderScorecard(root, { days = DEFAULT_DAYS, now = new Date() } = {}) {
+  const bounds = historyBounds(now, days);
+  const perRepo = collectRepoScorecards(root, bounds);
+  const commitsThisWeek = perRepo.reduce((total, repo) => total + repo.commitsThisWeek, 0);
+  const commitsLastWeek = perRepo.reduce((total, repo) => total + repo.commitsLastWeek, 0);
+  const tasks = readTaskScorecard(root, bounds);
+
+  return {
+    ts: now.toISOString(),
+    days,
+    commitsThisWeek,
+    commitsLastWeek,
+    slopePct: percentChange(commitsThisWeek, commitsLastWeek),
+    tasksThisWeek: tasks.thisWeek,
+    tasksLastWeek: tasks.lastWeek,
+    perRepo,
+  };
+}
+
+function appendFounderScorecard(currentWorkspace, scorecard) {
+  const file = path.join(currentWorkspace, SCORECARD_FILE);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(scorecard)}\n`, 'utf8');
+  return file;
+}
+
+function plural(count, word) {
+  return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+
+function slopeText(value) {
+  return value > 0 ? `+${value}%` : `${value}%`;
+}
+
+function renderFounderScorecard(scorecard) {
+  const activeProjects = scorecard.perRepo.filter((repo) => repo.commitsThisWeek > 0).length;
+  const lines = [
+    `last 7 days: ${plural(scorecard.commitsThisWeek, 'commit')} landed across ${plural(activeProjects, 'project')}. prior 7 days: ${scorecard.commitsLastWeek}. slope: ${slopeText(scorecard.slopePct)}.`,
+  ];
+
+  for (const repo of scorecard.perRepo.filter((entry) => (
+    entry.commitsThisWeek > 0 || entry.commitsLastWeek > 0
+  )).slice(0, 5)) {
+    lines.push(`${repo.repo}: ${repo.commitsThisWeek} last 7 days, ${repo.commitsLastWeek} prior 7 days.`);
+  }
+
+  if (scorecard.tasksThisWeek === null) lines.push('no task data.');
+  else lines.push(`tasks closed: ${scorecard.tasksThisWeek} last 7 days, ${scorecard.tasksLastWeek} prior 7 days.`);
+  return lines.join('\n');
+}
+
+function showFounderHelp() {
+  console.log('usage: atris founder [score] [--days n] [--root dir]');
+  console.log('shows the last 7 days against the prior 7 days from git and task receipts.');
+}
+
+function founderCommand(args = [], options = {}) {
+  let parsed;
+  try {
+    parsed = parseArgs(args);
+  } catch (error) {
+    console.error(`error: ${error.message}`);
+    return 1;
+  }
+  if (parsed.help) {
+    showFounderHelp();
+    return 0;
+  }
+
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const currentWorkspace = workspaceRoot(cwd);
+  const root = parsed.root
+    ? path.resolve(cwd, parsed.root)
+    : defaultScanRoot(cwd, currentWorkspace);
+  const now = founderNow(options.env || process.env);
+  const scorecard = buildFounderScorecard(root, { days: parsed.days, now });
+  appendFounderScorecard(currentWorkspace, scorecard);
+  console.log(renderFounderScorecard(scorecard));
+  return 0;
+}
+
+module.exports = { founderCommand };