atris 3.35.0 → 3.37.0

package/lib/codex-flight.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+
+const CODEX_COMPANION = '/Users/keshavrao/.claude/plugins/cache/openai-codex/codex/1.0.4/scripts/codex-companion.mjs';
+const CONTRACT = "CRITICAL: complete the entire job in this single run; never end your reply on a plan. Do NOT run any atris boot/brain/state commands; the only atris commands allowed are 'atris worktree guard' and 'atris worktree ship'.";
+const COAUTHOR = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
+
+function safeSlug(value) {
+  return String(value || 'mission')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48) || 'mission';
+}
+
+function stamp() {
+  return new Date().toISOString()
+    .replace(/[-:]/g, '')
+    .replace(/\.\d{3}Z$/, 'Z');
+}
+
+function shellQuote(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_./:=@+-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function repoParts(repoPath) {
+  const resolved = path.resolve(repoPath || process.cwd());
+  const parts = resolved.split(path.sep);
+  const worktreesIndex = parts.lastIndexOf('.agent-worktrees');
+  if (worktreesIndex >= 0 && parts[worktreesIndex + 1]) {
+    return {
+      repoPath: resolved,
+      repoName: parts[worktreesIndex + 1],
+      arenaRoot: parts.slice(0, worktreesIndex).join(path.sep) || path.sep,
+    };
+  }
+  return {
+    repoPath: resolved,
+    repoName: path.basename(resolved),
+    arenaRoot: path.dirname(resolved),
+  };
+}
+
+function buildPrompt({ worktreePath, branch, brief, verifyCmd }) {
+  const verify = String(verifyCmd || 'git diff --check').trim() || 'git diff --check';
+  return [
+    CONTRACT,
+    `Worktree: ${worktreePath}`,
+    `Branch: ${branch}`,
+    '',
+    String(brief || '').trim(),
+    '',
+    'Instructions:',
+    `- First run: atris worktree guard`,
+    `- Verify with this bare command and use its real exit code: ${verify}`,
+    '- Stage and commit only files you changed.',
+    `- Commit with a plain-English message and include this trailer: ${COAUTHOR}`,
+    `- Run: atris worktree ship --message "<plain-English summary>" --verify "${verify.replace(/"/g, '\\"')}" --merge`,
+    '- Report the PR URL, commit sha, verify exit code, and ship exit code.',
+    '- If rebase or merge reports a conflict, stop immediately and report the conflict; do not resolve it yourself.',
+    '- If a git hook blocks your commit, STOP and report it; never bypass it with --no-verify.',
+  ].join('\n');
+}
+
+function renderCommand(argv) {
+  return argv.map(shellQuote).join(' ');
+}
+
+function runWorktreeAdd(repoPath, branch, worktreePath) {
+  fs.mkdirSync(path.dirname(worktreePath), { recursive: true });
+  const baseArgs = ['-C', repoPath, 'worktree', 'add', '-b', branch, worktreePath];
+  const master = spawnSync('git', [...baseArgs, 'origin/master'], { encoding: 'utf8' });
+  if (master.status === 0) return { baseRef: 'origin/master' };
+  const main = spawnSync('git', [...baseArgs, 'origin/main'], { encoding: 'utf8' });
+  if (main.status === 0) return { baseRef: 'origin/main' };
+  const detail = [
+    `origin/master: ${(master.stderr || master.stdout || '').trim()}`,
+    `origin/main: ${(main.stderr || main.stdout || '').trim()}`,
+  ].join('\n');
+  throw new Error(`git worktree add failed for ${worktreePath}\n${detail}`);
+}
+
+function parseTaskId(stdout) {
+  const text = String(stdout || '');
+  const jsonMatch = text.match(/"jobId"\s*:\s*"([^"]+)"/);
+  if (jsonMatch) return jsonMatch[1];
+  const taskMatch = text.match(/\b(task-[A-Za-z0-9_.:-]+)\b/);
+  if (taskMatch) return taskMatch[1];
+  const asMatch = text.match(/\bas\s+([A-Za-z0-9_.:-]+)\b/);
+  return asMatch ? asMatch[1] : '';
+}
+
+function spawnCodex(worktreePath, prompt) {
+  return new Promise((resolve, reject) => {
+    const argv = [CODEX_COMPANION, 'task', '--background', '--write', prompt];
+    const child = spawn('node', argv, {
+      cwd: worktreePath,
+      env: { ...process.env, CODEX_COMPANION_SANDBOX: 'danger-full-access' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`codex companion exited ${code}\n${stderr || stdout}`));
+        return;
+      }
+      const taskId = parseTaskId(stdout);
+      if (!taskId) {
+        reject(new Error(`could not parse codex task id from stdout\n${stdout}`));
+        return;
+      }
+      resolve({ taskId, stdout, stderr });
+    });
+  });
+}
+
+async function dispatchCodexFlight({ repoPath, slug, brief, verifyCmd, dryRun = false } = {}) {
+  const repo = repoParts(repoPath);
+  const flightSlug = safeSlug(slug);
+  const flightStamp = stamp();
+  const branch = `codex/${flightSlug}-${flightStamp}`;
+  const worktreePath = path.join(repo.arenaRoot, '.agent-worktrees', repo.repoName, `codex-${flightSlug}-${flightStamp}`);
+  const prompt = buildPrompt({ worktreePath, branch, brief, verifyCmd });
+  const worktreeCommand = ['git', '-C', repo.repoPath, 'worktree', 'add', '-b', branch, worktreePath, 'origin/master'];
+  const fallbackCommand = ['git', '-C', repo.repoPath, 'worktree', 'add', '-b', branch, worktreePath, 'origin/main'];
+
+  if (dryRun) {
+    console.log(`Worktree command: ${renderCommand(worktreeCommand)}`);
+    console.log(`Fallback command: ${renderCommand(fallbackCommand)}`);
+    console.log(`Codex cwd: ${worktreePath}`);
+    console.log('Prompt:');
+    console.log(prompt);
+    return { dryRun: true, prompt };
+  }
+
+  runWorktreeAdd(repo.repoPath, branch, worktreePath);
+  const task = await spawnCodex(worktreePath, prompt);
+  return { taskId: task.taskId, worktreePath, branch };
+}
+
+module.exports = {
+  dispatchCodexFlight,
+  buildPrompt,
+  parseTaskId,
+};

package/lib/default-runner.js

@@ -0,0 +1,45 @@
+'use strict';
+
+// Self-contained flag reads so this helper can be shared by commands/mission.js
+// and commands/member.js, which each define their own readFlag/hasFlag. Handles
+// both `--flag value` and `--flag=value`.
+function flagValue(args, name) {
+  const list = Array.isArray(args) ? args : [];
+  const eq = `${name}=`;
+  for (let i = 0; i < list.length; i += 1) {
+    const token = String(list[i]);
+    if (token === name) return i + 1 < list.length ? String(list[i + 1]) : '';
+    if (token.startsWith(eq)) return token.slice(eq.length);
+  }
+  return '';
+}
+
+function hasFlag(args, name) {
+  const list = Array.isArray(args) ? args : [];
+  return list.some((token) => String(token) === name || String(token).startsWith(`${name}=`));
+}
+
+// A live codex session drives a run by passing its native goal slot state
+// (--native-goal-* / --visible-goal-*) or by explicitly claiming the slot
+// (--take-goal-slot). Absent those, nothing is on the other end.
+function runHasLiveCodexSession(args) {
+  return Boolean(
+    flagValue(args, '--native-goal-status')
+    || flagValue(args, '--visible-goal-status')
+    || flagValue(args, '--native-goal-objective')
+    || flagValue(args, '--visible-goal-objective')
+    || hasFlag(args, '--take-goal-slot'),
+  );
+}
+
+// Default runner for the run-objective path (`atris mission run "<objective>"`,
+// `member run`). codex_goal hands the mission to a live codex session's native
+// goal slot; with no such session (cron, fleet, a plain shell) it stalls forever
+// waiting for a native goal start that never comes (proven footgun 2026-07-16).
+// So codex_goal only when a live codex session is driving; otherwise claude,
+// which drives itself headless. An explicit --runner always wins over this.
+function defaultObjectiveRunner(args) {
+  return runHasLiveCodexSession(args) ? 'codex_goal' : 'claude';
+}
+
+module.exports = { runHasLiveCodexSession, defaultObjectiveRunner };

package/lib/default-verifier.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_MISSION_VERIFIER_TIMEOUT_MS = 120000;
+
+// allowBroadSuite=false is for callers that FREEZE this as a mission's default
+// verifier. A broad suite (`npm test`, `node --test`) auto-selected as a silent
+// default is a proven footgun: in atrisos-backend `npm test` runs
+// backend/scripts/test_fast.sh, which fails without its env and killed missions
+// after two ticks (2026-07-16). A default the operator never chose must be a
+// check that reflects the mission's own work, not the whole repo's health — so
+// the mission lane falls back to the always-safe `git diff --check` and leaves
+// broad suites to explicit `--verify`. Fleet/wish keep the suite default.
+function resolveDefaultVerifier(root = process.cwd(), { allowBroadSuite = true } = {}) {
+  const repoRoot = path.resolve(root);
+  if (allowBroadSuite) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+      if (pkg.scripts && pkg.scripts.test) return 'npm test';
+    } catch {}
+    try {
+      if (fs.statSync(path.join(repoRoot, 'test')).isDirectory()) return 'node --test';
+    } catch {}
+  }
+  return 'git diff --check';
+}
+
+function missionVerifierTimeoutMs(env = process.env) {
+  const parsed = Number(env.ATRIS_MISSION_VERIFIER_TIMEOUT_MS);
+  if (Number.isFinite(parsed) && parsed >= 1000) return Math.floor(parsed);
+  return DEFAULT_MISSION_VERIFIER_TIMEOUT_MS;
+}
+
+function broadSuiteVerifier(command) {
+  const compact = String(command || '').trim().replace(/\s+/g, ' ');
+  return compact === 'node --test'
+    || compact === 'node --test .'
+    || compact === 'node --test test'
+    || compact === 'node --test tests'
+    || compact === 'npm test';
+}
+
+function verifierWindowText(timeoutMs) {
+  const minutes = timeoutMs / 60000;
+  if (minutes === 1) return 'one minute';
+  if (minutes === 2) return 'two minutes';
+  if (Number.isInteger(minutes)) return `${minutes} minutes`;
+  return `${Math.round(timeoutMs / 1000)} seconds`;
+}
+
+function verifierBudgetWarning(command, env = process.env) {
+  if (!broadSuiteVerifier(command)) return null;
+  const timeoutMs = missionVerifierTimeoutMs(env);
+  return {
+    code: 'verifier_may_outlive_window',
+    message: `warning: this wish uses the whole test suite, but mission verification stops after ${verifierWindowText(timeoutMs)}. add a focused check command if that suite runs longer.`,
+    verifier: String(command || '').trim(),
+    verifier_timeout_ms: timeoutMs,
+  };
+}
+
+module.exports = {
+  DEFAULT_MISSION_VERIFIER_TIMEOUT_MS,
+  broadSuiteVerifier,
+  missionVerifierTimeoutMs,
+  resolveDefaultVerifier,
+  verifierBudgetWarning,
+};

package/lib/engine-registry.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  RUNNER_PROFILE_NAMES,
+} = require('./runner-command');
+const { rankEnginesDetailed, routerPickExplanation } = require('./router-brain');
+
+const ENGINE_REGISTRY_SCHEMA = 'atris.engine_registry.v2';
+const ENGINE_TIERS = Object.freeze(['fast', 'pro', 'max']);
+const ENGINE_ROLES = Object.freeze(['navigator', 'executor', 'validator']);
+const ENGINE_HEALTH_STATUSES = Object.freeze(['ready', 'not_installed', 'credit_out', 'error']);
+
+const ENGINE_SEED_META = Object.freeze({
+  'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), fallback_order: 10 }),
+  codex: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 10 }),
+  claude: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), fallback_order: 20 }),
+  cursor: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 30 }),
+  devin: Object.freeze({ tier: 'max', roles: Object.freeze(['executor']), fallback_order: 40 }),
+  grok: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 45 }),
+  fable: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), fallback_order: 50 }),
+  composer: Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator', 'executor']), fallback_order: 60 }),
+  haiku: Object.freeze({ tier: 'fast', roles: Object.freeze(['validator']), fallback_order: 70 }),
+  hermes: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 80 }),
+  droid: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), fallback_order: 90 }),
+});
+
+function engineRegistryFile(root = process.cwd()) {
+  return path.join(root, '.atris', 'state', 'engines.json');
+}
+
+function binInstalled(bin) {
+  const safe = String(bin || '').replace(/[^A-Za-z0-9_.-]/g, '');
+  if (!safe) return false;
+  const probe = spawnSync('sh', ['-c', `command -v ${safe}`], { encoding: 'utf8' });
+  return probe.status === 0 && Boolean(String(probe.stdout || '').trim());
+}
+
+function canonicalEngineName(name) {
+  const trimmed = String(name || '').trim();
+  if (!trimmed) return '';
+  if (RUNNER_PROFILE_DEFS[trimmed]) return trimmed;
+  if (RUNNER_PROFILE_ALIASES[trimmed]) return RUNNER_PROFILE_ALIASES[trimmed];
+  return '';
+}
+
+function readRawRegistry(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (Array.isArray(parsed)) return { engines: parsed };
+    if (parsed && Array.isArray(parsed.engines)) return parsed;
+  } catch {}
+  return { engines: [] };
+}
+
+function normalizeTier(value, fallback = 'pro') {
+  const tier = String(value || '').trim();
+  return ENGINE_TIERS.includes(tier) ? tier : fallback;
+}
+
+function normalizeRoles(value, fallback = ['executor']) {
+  const roles = Array.isArray(value) ? value.map((role) => String(role || '').trim()) : [];
+  const filtered = roles.filter((role, index) => ENGINE_ROLES.includes(role) && roles.indexOf(role) === index);
+  return filtered.length ? filtered : fallback;
+}
+
+function normalizeFallbackOrder(value, fallback) {
+  const order = Number(value);
+  return Number.isInteger(order) ? order : fallback;
+}
+
+function normalizeEngineEntry(id, saved = {}) {
+  const def = RUNNER_PROFILE_DEFS[id];
+  const seed = ENGINE_SEED_META[id] || { tier: 'pro', roles: ['executor'], fallback_order: 100 };
+  const installed = binInstalled(def.bin);
+  const savedHealth = saved && saved.health && typeof saved.health === 'object' ? saved.health : {};
+  const savedStatus = String(savedHealth.status || '').trim();
+  const savedFailure = savedStatus === 'credit_out'
+    || savedStatus === 'error'
+    || (savedStatus === 'not_installed' && Boolean(savedHealth.last_failure_ts));
+  const status = savedFailure ? savedStatus : (installed ? 'ready' : 'not_installed');
+  const health = { status };
+  if (savedFailure && savedHealth.last_failure_ts) health.last_failure_ts = String(savedHealth.last_failure_ts);
+  return {
+    id,
+    name: id,
+    bin: def.bin,
+    tier: normalizeTier(saved.tier, seed.tier),
+    roles: normalizeRoles(saved.roles, Array.from(seed.roles)),
+    fallback_order: normalizeFallbackOrder(saved.fallback_order, seed.fallback_order),
+    installed,
+    health,
+  };
+}
+
+function seededRegistry(root = process.cwd()) {
+  const file = engineRegistryFile(root);
+  const raw = readRawRegistry(file);
+  const savedById = new Map();
+  for (const entry of raw.engines || []) {
+    const id = canonicalEngineName(entry && (entry.id || entry.name));
+    if (id) savedById.set(id, entry);
+  }
+  return {
+    schema: ENGINE_REGISTRY_SCHEMA,
+    updated_at: new Date().toISOString(),
+    engines: RUNNER_PROFILE_NAMES.map((id) => normalizeEngineEntry(id, savedById.get(id) || {})),
+  };
+}
+
+function writeEngineRegistry(root, registry) {
+  const file = engineRegistryFile(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(registry, null, 2)}\n`, 'utf8');
+}
+
+function readEngineRegistry(root = process.cwd(), options = {}) {
+  const registry = seededRegistry(root);
+  if (options.persist !== false) writeEngineRegistry(root, registry);
+  return registry;
+}
+
+function engineRegistryView(root = process.cwd()) {
+  return readEngineRegistry(root).engines;
+}
+
+function registeredEngineIds(root = process.cwd()) {
+  return engineRegistryView(root).map((engine) => engine.id);
+}
+
+function resolveRegisteredEngine(name, root = process.cwd()) {
+  const requested = String(name || '').trim();
+  const id = canonicalEngineName(requested);
+  const engines = engineRegistryView(root);
+  const knownIds = engines.map((engine) => engine.id);
+  const engine = id ? engines.find((entry) => entry.id === id) : null;
+  if (!engine) {
+    throw new Error(`Unknown engine "${requested}". Registered engine ids: ${knownIds.join(', ')}`);
+  }
+  return engine;
+}
+
+function resolveEngineForRole(role, root = process.cwd(), options = {}) {
+  const normalizedRole = String(role || '').trim().toLowerCase();
+  if (!ENGINE_ROLES.includes(normalizedRole)) {
+    throw new Error(`Unknown role "${role}". Known roles: ${ENGINE_ROLES.join(', ')}`);
+  }
+  const engines = engineRegistryView(root)
+    .filter((engine) => engine.roles.includes(normalizedRole))
+    .filter((engine) => engine.health && engine.health.status === 'ready')
+    .sort((a, b) => {
+      const byOrder = Number(a.fallback_order) - Number(b.fallback_order);
+      return byOrder || String(a.id).localeCompare(String(b.id));
+    });
+  const ranked = rankEnginesDetailed(engines, {
+    root,
+    taskType: options.taskType || options.task_type || normalizedRole,
+  });
+  const selected = ranked.candidates[0] || null;
+  if (selected && process.env.ATRIS_ROUTER_EXPLAIN === '1') {
+    console.error(routerPickExplanation(ranked));
+  }
+  return selected;
+}
+
+function resolveEngineForRoleWithPreference(role, root = process.cwd(), preferredEngineId = '', options = {}) {
+  const requested = String(preferredEngineId || '').trim();
+  if (!requested) {
+    return {
+      engine: resolveEngineForRole(role, root, options),
+      requested_engine: null,
+      engine_fallback_reason: null,
+    };
+  }
+  const preferred = resolveRegisteredEngine(requested, root);
+  if (preferred.health && preferred.health.status === 'ready') {
+    return {
+      engine: preferred,
+      requested_engine: preferred.id,
+      engine_fallback_reason: null,
+    };
+  }
+  const fallback = resolveEngineForRole(role, root, options);
+  const status = preferred.health && preferred.health.status ? preferred.health.status : 'unknown';
+  return {
+    engine: fallback,
+    requested_engine: preferred.id,
+    engine_fallback_reason: `Requested engine ${preferred.id} is not ready (${status}); fell back to ${fallback ? fallback.id : 'no ready executor'}.`,
+  };
+}
+
+function setEngineHealth(name, status, root = process.cwd()) {
+  const id = canonicalEngineName(name);
+  if (!id) {
+    throw new Error(`Unknown engine "${name}". Known engines: ${RUNNER_PROFILE_NAMES.join(', ')}`);
+  }
+  const normalizedStatus = String(status || '').trim();
+  if (!ENGINE_HEALTH_STATUSES.includes(normalizedStatus)) {
+    throw new Error(`Unknown health "${status}". Known health statuses: ${ENGINE_HEALTH_STATUSES.join(', ')}`);
+  }
+  const registry = readEngineRegistry(root, { persist: false });
+  const engines = registry.engines.map((engine) => {
+    if (engine.id !== id) return engine;
+    const health = { status: normalizedStatus };
+    if (normalizedStatus !== 'ready') health.last_failure_ts = new Date().toISOString();
+    return { ...engine, health };
+  });
+  const next = { ...registry, updated_at: new Date().toISOString(), engines };
+  writeEngineRegistry(root, next);
+  return engines.find((engine) => engine.id === id);
+}
+
+module.exports = {
+  ENGINE_REGISTRY_SCHEMA,
+  ENGINE_TIERS,
+  ENGINE_ROLES,
+  ENGINE_HEALTH_STATUSES,
+  engineRegistryFile,
+  binInstalled,
+  canonicalEngineName,
+  readEngineRegistry,
+  engineRegistryView,
+  registeredEngineIds,
+  resolveRegisteredEngine,
+  resolveEngineForRole,
+  resolveEngineForRoleWithPreference,
+  setEngineHealth,
+};