atris 3.64.0 → 3.65.0

package/lib/engine-processes.js

@@ -0,0 +1,430 @@
+'use strict';
+
+// Who is working right now: engine runs alive on this machine, read from one
+// `ps` call. A run belongs to a member when its prompt says "acting as
+// <member>" (the dispatch convention); otherwise it shows as unattached.
+// Nothing here starts or stops anything.
+//
+// ps joins a launch's words with spaces, so where the prompt starts and ends
+// is a guess. The rules: a known engine program is always a row unless it is
+// plainly an interactive session; settings are read only where atris's own
+// launchers put them (test/roster-team-tables.test.js builds every launch
+// from those launchers, so a new flag that breaks this fails a test); and
+// when the words cannot be read with confidence the model shows as unknown
+// rather than a guess.
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { engineModelText } = require('./roster-models');
+const { EFFORT_WORDS } = require('./runner-command');
+const { readMemberLaunch } = require('./member-identity');
+
+const PS_ARGS = ['-axo', 'pid=,ppid=,etime=,command='];
+
+// Each engine CLI's settings: the flags that take the next word as a value
+// and the flags that stand alone. A flag in neither list makes the reading
+// unsure.
+const SHARED_VALUES = ['-m', '--model', '--effort', '--add-dir', '--prompt-file', '--output-format'];
+const SHARED_SWITCHES = ['-p', '--print', '--help', '-h', '--version', '--verbose', '--json'];
+
+const ENGINE_FLAGS = {
+  codex: {
+    values: ['-c', '--config', '-s', '--sandbox', '-o', '--output-last-message', '-C', '--cd', '-p', '--profile',
+      '-i', '--image', '--color', '--output-schema', '-a', '--ask-for-approval', '--enable', '--disable'],
+    switches: ['--ephemeral', '--ignore-user-config', '--ignore-rules', '--dangerously-bypass-approvals-and-sandbox',
+      '--skip-git-repo-check', '--full-auto', '--oss'],
+  },
+  claude: {
+    values: ['--tools', '--permission-mode', '--input-format', '--allowedTools', '--allowed-tools', '--disallowedTools',
+      '--disallowed-tools', '--append-system-prompt', '--system-prompt', '--session-id', '--resume', '-r', '--max-turns',
+      '--mcp-config', '--settings', '--agents', '--fallback-model'],
+    switches: ['--no-session-persistence', '--dangerously-skip-permissions', '--safe-mode', '--include-partial-messages',
+      '--strict-mcp-config', '-c', '--continue'],
+  },
+  cursor: {
+    values: ['--mode', '--sandbox', '--api-key', '--resume'],
+    switches: ['--trust', '--force', '-f', '--stream-partial-output'],
+  },
+  devin: {
+    values: ['--permission-mode', '--respect-workspace-trust'],
+    switches: ['--sandbox'],
+  },
+  grok: {
+    values: ['--permission-mode', '--sandbox', '--reasoning-effort', '--best-of-n'],
+    switches: ['--always-approve', '--no-memory', '--no-subagents'],
+  },
+  agy: {
+    values: ['--mode', '--print-timeout'],
+    switches: ['--sandbox', '--dangerously-skip-permissions'],
+  },
+  droid: {
+    values: ['--reasoning-effort', '--append-system-prompt', '--cwd'],
+    switches: ['--auto', '--skip-permissions-unsafe'],
+  },
+  opencode: {
+    values: ['--variant', '--agent', '-s', '--session', '--format', '-f', '--file'],
+    switches: ['--auto'],
+  },
+  'atris-fast': {
+    values: ['--business', '--verify', '--approve', '--deny', '--grant', '--revoke-grant'],
+    switches: ['--auto', '--max', '--pro', '--fast', '--rapid', '--alpha', '--code-fast', '--local', '--cloud', '--chat',
+      '--doctor', '--approvals', '--grants', '--sync-grants', '--auto-approve', '--self-test', '--benchmark'],
+  },
+  commandcode: {
+    values: [],
+    switches: ['--yolo', '--trust'],
+  },
+  atris: {
+    values: ['--engine', '--member', '--minutes', '--job', '--timeout', '--jobs', '--scope'],
+    switches: ['--personal'],
+  },
+};
+for (const spec of Object.values(ENGINE_FLAGS)) {
+  spec.values = new Set([...SHARED_VALUES, ...spec.values]);
+  spec.switches = new Set([...SHARED_SWITCHES, ...spec.switches]);
+}
+
+const AX_CONTROL_FLAGS = new Set([
+  '--chat', '--doctor', '--approvals', '--approve', '--deny', '--grant', '--grants', '--sync-grants',
+  '--revoke-grant', '--auto-approve', '--self-test', '--benchmark', '--help', '-h', '--version',
+]);
+const ATRIS_RUN_VERBS = ['ask', 'dispatch', 'validate', 'bench', 'test'];
+
+const printing = ({ flags }) => hasFlag(flags, ['-p', '--print']);
+
+// What makes a launch a run. Where an interactive session looks different
+// from a headless one (codex exec, claude -p) the difference is required;
+// anywhere else a launch with work in it is a run. A string names the engine
+// when the launcher is atris itself.
+const RUN_RULES = {
+  codex: ({ command }) => command[0] === 'exec',
+  droid: ({ command }) => command[0] === 'exec',
+  claude: printing,
+  // `atris agent spawn` launches `cursor-agent <prompt>` with no -p.
+  cursor: (split) => printing(split) || split.prompt.length > 0,
+  devin: printing,
+  grok: printing,
+  agy: printing,
+  opencode: ({ command }) => command[0] === 'run',
+  'atris-fast': ({ flags, prompt }) => !flags.some(([name]) => AX_CONTROL_FLAGS.has(name)) && prompt.length > 0,
+  commandcode: printing,
+  atris: atrisRunEngine,
+};
+
+// Subcommand words ahead of the settings.
+function subcommandCount(engine, args) {
+  if (engine === 'codex' || engine === 'droid' || engine === 'opencode') return 1;
+  if (engine === 'atris') return args[0] === 'engine' ? 2 : 1;
+  return 0;
+}
+
+// `atris engine ask|dispatch|validate ...` runs the engine it names;
+// `atris engine fable <question>` asks fable; `atris chat --print` is Atris
+// Fast. Anything else atris does is not an engine run.
+function atrisRunEngine({ command, flags, prompt }) {
+  if (command[0] === 'chat') return printing({ flags }) && prompt.length > 0 ? 'atris-fast' : false;
+  if (command[0] !== 'engine') return false;
+  const named = canonicalEngine(flagValue(flags, ['--engine']));
+  if (ATRIS_RUN_VERBS.includes(command[1])) return named || 'atris';
+  return canonicalEngine(command[1]) || false;
+}
+
+function canonicalEngine(name) {
+  if (!name) return '';
+  const { canonicalEngineName } = require('./engine-registry');
+  try { return canonicalEngineName(name) || ''; } catch { return ''; }
+}
+
+// The program at the front of a launch -> the engine name the roster uses.
+const BINARY_ENGINES = Object.freeze({
+  claude: 'claude', 'cursor-agent': 'cursor', droid: 'droid', devin: 'devin', grok: 'grok', agy: 'agy', opencode: 'opencode',
+  ax: 'atris-fast', cmd: 'commandcode', atris: 'atris',
+});
+
+// ax picks its model by mode flag; --fast is the atris-fast profile's model.
+const AX_MODES = ['auto', 'max', 'pro', 'fast', 'rapid', 'alpha', 'code-fast'];
+
+const INTERPRETERS = new Set(['node', 'bun', 'deno']);
+
+function engineOf(token) {
+  const text = String(token || '');
+  const base = path.basename(text).replace(/\.(c?js|mjs)$/, '');
+  // The native codex binary can carry a platform suffix; codex-watchdog is
+  // atris's wrapper, not codex.
+  if (/^codex(-(?:aarch64|arm64|x86_64|x64)[a-z0-9_-]*)?$/.test(base)) return 'codex';
+  if (Object.prototype.hasOwnProperty.call(BINARY_ENGINES, base)) return BINARY_ENGINES[base];
+  // Command Code run straight from its package file.
+  if (/[\\/]command-code[\\/]dist[\\/]index\.m?js$/.test(text)) return 'commandcode';
+  return '';
+}
+
+// "1-02:03:04", "02:03:04", "03:04" -> seconds.
+function parseElapsed(text) {
+  const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(String(text || '').trim());
+  if (!match) return null;
+  const [, days, hours, minutes, seconds] = match.map((part) => Number(part || 0));
+  return days * 86400 + hours * 3600 + minutes * 60 + seconds;
+}
+
+// "now", "6m", "2h", "3d".
+function shortElapsed(seconds) {
+  const value = Number(seconds);
+  if (!Number.isFinite(value) || value < 0) return '-';
+  if (value < 60) return 'now';
+  if (value < 3600) return `${Math.floor(value / 60)}m`;
+  if (value < 86400) return `${Math.floor(value / 3600)}h`;
+  return `${Math.floor(value / 86400)}d`;
+}
+
+function parsePsLine(line) {
+  const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(String(line || ''));
+  if (!match) return null;
+  return { pid: Number(match[1]), ppid: Number(match[2]), elapsed_seconds: parseElapsed(match[3]), command: match[4] };
+}
+
+// The one place a launch is split. argv -> the subcommand words, the
+// settings before the prompt, the prompt, and the settings after it.
+// Leading settings stop at "--" or at the first word that is neither a flag
+// nor a flag's value. Atris puts some settings after the prompt (claude
+// --model, devin --model, fleet's sandbox flags); those count only when every
+// word to the end is a known setting, any model named is a real model id, and
+// there was no "--". `unsure` is set when a flag the engine list does not
+// know came before the prompt, so its value could not be told from prose.
+function splitArgs(engine, args) {
+  const spec = ENGINE_FLAGS[engine];
+  const command = args.slice(0, subcommandCount(engine, args));
+  const flags = [];
+  let unsure = false;
+  let i = command.length;
+  for (; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--') return { command, flags, prompt: args.slice(i + 1), dashed: true, unsure, tail: [] };
+    if (!arg.startsWith('-') || arg === '-') break;
+    const eq = arg.indexOf('=');
+    if (arg.startsWith('--') && eq > 0) {
+      flags.push([arg.slice(0, eq), arg.slice(eq + 1)]);
+      if (!spec.values.has(arg.slice(0, eq)) && !spec.switches.has(arg.slice(0, eq))) unsure = true;
+    } else if (spec.values.has(arg) && i + 1 < args.length) {
+      flags.push([arg, args[i + 1]]);
+      i += 1;
+    } else {
+      flags.push([arg, true]);
+      if (!spec.switches.has(arg)) unsure = true;
+    }
+  }
+  const rest = args.slice(i);
+  const tail = trailingSettings(spec, rest);
+  return {
+    command,
+    flags,
+    prompt: tail ? rest.slice(0, tail.at) : rest,
+    dashed: false,
+    unsure,
+    tail: tail ? tail.flags : [],
+  };
+}
+
+function looksLikeModel(value) {
+  const text = String(value || '');
+  if (/\d|\//.test(text)) return true;
+  const { isClaudeFamilyModel } = require('./engine-registry');
+  return isClaudeFamilyModel(text);
+}
+
+const EFFORT_VALUES = new Set([...EFFORT_WORDS, 'off', 'none', 'minimal']);
+
+// The settings at the very end of a launch, read right to left: each step
+// takes a known setting (with its value) off the end, and stops at the first
+// word that is not one, at a setting already taken (a launcher never says a
+// setting twice, so a repeat belongs to the prompt), or at a model or effort
+// value that is not real. At least one prompt word always stays. So a prompt
+// ending "Explain --model <some model>" keeps its words, and the launcher's
+// own "--model <its model> ..." after it is what counts.
+function trailingSettings(spec, words) {
+  const known = (name) => spec.values.has(name) || spec.switches.has(name);
+  const flags = [];
+  const seen = new Set();
+  let at = words.length;
+  while (at > 1) {
+    const word = words[at - 1];
+    const before = words[at - 2];
+    let item = null;
+    let width = 1;
+    const eq = word.startsWith('--') ? word.indexOf('=') : -1;
+    if (eq > 0 && known(word.slice(0, eq))) item = [word.slice(0, eq), word.slice(eq + 1)];
+    else if (!word.startsWith('-') && spec.values.has(before) && at > 2) { item = [before, word]; width = 2; }
+    else if (spec.switches.has(word) && word !== '-p' && word !== '--print') item = [word, true];
+    if (!item || seen.has(item[0])) break;
+    if ((item[0] === '--model' || item[0] === '-m') && !looksLikeModel(item[1])) break;
+    if ((item[0] === '--effort' || item[0] === '--reasoning-effort') && !EFFORT_VALUES.has(item[1])) break;
+    seen.add(item[0]);
+    if (item[0] === '--model') seen.add('-m');
+    if (item[0] === '-m') seen.add('--model');
+    flags.unshift(item);
+    at -= width;
+  }
+  return flags.length ? { at, flags } : null;
+}
+
+function hasFlag(flags, names) {
+  return flags.some(([name]) => names.includes(name));
+}
+
+function flagValue(flags, names) {
+  const found = flags.find(([name, value]) => names.includes(name) && typeof value === 'string');
+  return found ? found[1] : '';
+}
+
+function effortOf(flags) {
+  const direct = flagValue(flags, ['--effort', '--reasoning-effort', '--variant']);
+  if (direct) return direct;
+  for (const [name, value] of flags) {
+    if (name !== '-c' && name !== '--config') continue;
+    const match = /^model_reasoning_effort=["']?([a-z]+)/.exec(String(value));
+    if (match) return match[1];
+  }
+  return '';
+}
+
+function promptText(split) {
+  if (split.prompt.length) return split.prompt.join(' ');
+  const file = flagValue(split.flags, ['--prompt-file']);
+  return file ? `prompt file ${path.basename(file)}` : '';
+}
+
+// A prompt can run to pages; the view needs its first line.
+const DOING_MAX = 240;
+
+// What the run is for, on one line, without the dispatch preamble
+// ("Read <path>/MEMBER.md first.").
+function doingText(text) {
+  const doing = String(text || '').replace(/^(?:first,?\s+)?read\s+\S+\s+first[.,]?\s*/i, '');
+  return doing.length > DOING_MAX ? `${doing.slice(0, DOING_MAX - 1).trimEnd()}…` : doing;
+}
+
+function axModel(engine, flags) {
+  if (engine !== 'atris-fast') return '';
+  const mode = AX_MODES.find((name) => hasFlag(flags, [`--${name}`]));
+  return mode ? `atris:${mode}` : '';
+}
+
+// An unsure reading: an unknown flag came before the prompt, so the words
+// after it may be its value or the prompt. Read every flag-looking word
+// before "--" as a setting just to decide whether this is a run, and take the
+// prompt from after the -p when there is one.
+function looseSplit(engine, args, split) {
+  const dash = args.indexOf('--');
+  const head = dash === -1 ? args : args.slice(0, dash);
+  const flags = head.filter((word) => word.startsWith('-')).map((word) => [word, true]);
+  const print = head.findIndex((word) => word === '-p' || word === '--print');
+  const after = print === -1 ? null : splitArgs(engine, [...split.command, ...args.slice(print + 1)]);
+  return { ...split, flags, prompt: after && after.prompt.length ? after.prompt : split.prompt };
+}
+
+// One ps line -> a run, or null when it is not an engine run at all.
+function parseEngineProcess(entry) {
+  if (!entry || !entry.command) return null;
+  const tokens = entry.command.trim().split(/\s+/);
+  let at = 0;
+  if (INTERPRETERS.has(path.basename(tokens[0] || ''))) at = 1;
+  // The orchestrator daemon is skipped by what it runs, never by what a
+  // prompt mentions ("Review orchestrator.py" is real work).
+  if (tokens.slice(0, at + 1).some((token) => /orchestrator/i.test(path.basename(token)))) return null;
+  const binary = engineOf(tokens[at]);
+  if (!binary) return null;
+  const args = tokens.slice(at + 1);
+  let split = splitArgs(binary, args);
+  let verdict = RUN_RULES[binary](split);
+  if (!verdict && split.unsure) {
+    split = looseSplit(binary, args, split);
+    verdict = RUN_RULES[binary](split);
+  }
+  if (!verdict) return null;
+  const engine = typeof verdict === 'string' ? verdict : binary;
+  const prompt = promptText(split);
+  const { member, doing } = readMemberLaunch(prompt);
+  const settings = split.unsure ? [] : [...split.flags, ...split.tail];
+  const model = flagValue(settings, ['-m', '--model']) || (split.unsure ? '' : axModel(binary, split.flags));
+  return {
+    pid: entry.pid,
+    ppid: entry.ppid,
+    engine,
+    model: model || null,
+    effort: effortOf(settings) || null,
+    member,
+    doing: doingText(doing) || '-',
+    elapsed_seconds: entry.elapsed_seconds,
+  };
+}
+
+// Every matched run above this one in the process tree. A shell may sit
+// between a dispatcher and the tool it runs, so the walk goes all the way up.
+function matchedAncestors(run, all, byPid) {
+  const out = [];
+  const seen = new Set();
+  let pid = run.ppid;
+  while (all.has(pid) && !seen.has(pid)) {
+    seen.add(pid);
+    if (byPid.has(pid)) out.push(byPid.get(pid));
+    pid = all.get(pid).ppid;
+  }
+  return out;
+}
+
+// Keep one run per real job. A node wrapper and the native binary it spawns
+// carry the same words, and a dispatcher (atris engine) sits above the tool
+// it runs: the deepest run wins, and an unnamed run takes the member of the
+// nearest named run above it. Only runs in one process line fold together:
+// two separate processes asking the same thing are two jobs.
+function liveEngineRuns(entries, { selfPid = process.pid } = {}) {
+  const all = new Map(entries.filter(Boolean).map((entry) => [entry.pid, entry]));
+  const runs = entries
+    .filter((entry) => entry && entry.pid !== selfPid)
+    .map(parseEngineProcess)
+    .filter(Boolean);
+  const byPid = new Map(runs.map((run) => [run.pid, run]));
+  const above = new Map(runs.map((run) => [run.pid, matchedAncestors(run, all, byPid)]));
+  for (const run of runs) {
+    if (run.member) continue;
+    const named = above.get(run.pid).find((item) => item.member);
+    if (named) run.member = named.member;
+  }
+  const hidden = new Set();
+  for (const run of runs) {
+    for (const item of above.get(run.pid)) {
+      if (!item.member || item.member === run.member) hidden.add(item.pid);
+    }
+  }
+  return runs
+    .filter((run) => !hidden.has(run.pid))
+    .map(({ ppid, ...run }) => run)
+    .sort((a, b) => (a.elapsed_seconds ?? Infinity) - (b.elapsed_seconds ?? Infinity));
+}
+
+// The live runs on this machine. deps.runPs returns { status, stdout } like
+// spawnSync; tests pass their own. A ps that fails means no runs, never an
+// error.
+function listLiveEngineRuns(deps = {}) {
+  const run = deps.runPs || (() => spawnSync('ps', PS_ARGS, { encoding: 'utf8', timeout: 3000, maxBuffer: 16 * 1024 * 1024 }));
+  let result;
+  try { result = run(PS_ARGS); } catch { return []; }
+  if (!result || result.status !== 0 || typeof result.stdout !== 'string') return [];
+  const entries = result.stdout.split(/\r?\n/).map(parsePsLine).filter(Boolean);
+  return liveEngineRuns(entries, { selfPid: deps.selfPid || process.pid });
+}
+
+// "<engine> · <model label>" for a live run.
+function liveRunEngineText(run) {
+  return (run && engineModelText(run.engine, run.model || '')) || '-';
+}
+
+module.exports = {
+  listLiveEngineRuns,
+  liveEngineRuns,
+  liveRunEngineText,
+  parseEngineProcess,
+  parsePsLine,
+  splitArgs,
+  shortElapsed,
+};

package/lib/engine-registry.js

@@ -923,16 +923,25 @@ function rosterPickFromValue(value, role, options = {}) {
   let namedModel = false;
   let namedEffort = false;
   let prep = '';
+  let verified = '';
   for (const raw of extras) {
-    // "max: 20 min" and "until: 2026-10-24" read like "max 20 min".
-    const part = raw.replace(/^(max|until)\s*:\s*/i, '$1 ');
+    // "max: 20 min", "until: 2026-10-24", and "verified: 2026-09-30" read
+    // like "max 20 min".
+    const part = raw.replace(/^(max|until|verified)\s*:\s*/i, '$1 ');
     const backupMatch = /^backup\s+(.+)$/i.exec(part);
     const untilMatch = /^until\s+(.+)$/i.exec(part);
     const maxMatch = /^max\b/i.test(part) && !/^max$/i.test(part);
     const modelMatch = /^model\s*(?::\s*|\s+)(.+)$/i.exec(part);
     const effortMatch = /^effort\s*(?::\s*|\s+)(.+)$/i.exec(part);
     const prepMatch = /^prep\s*(?::\s*|\s+)(.+)$/i.exec(part);
-    if (prepMatch && !prep) {
+    const verifiedMatch = /^verified\s+(.+)$/i.exec(part);
+    if (verifiedMatch && !verified) {
+      // "verified 2026-09-30": the day a person last saw this model answer.
+      // The roster flags a pin whose newest proof is over 30 days old.
+      const words = verifiedMatch[1].trim();
+      verified = parseRosterUntilWords(words);
+      if (!verified) throw new Error(`"verified ${words}" is not a date; use verified 2026-09-30`);
+    } else if (prepMatch && !prep) {
       // "prep: search": that job's lead reads the task first and hands this
       // worker a trimmed brief. Whether it names this same job is checked
       // where the job is known.
@@ -988,6 +997,7 @@ function rosterPickFromValue(value, role, options = {}) {
     until,
     ...(until ? {} : { never_expires: true }),
     ...(untilYearless ? { until_needs_year: untilYearless } : {}),
+    ...(verified ? { verified } : {}),
   };
 }
 
@@ -1030,6 +1040,7 @@ function rosterWorkerFromValue(value, role, options = {}) {
     until: pick.until,
     ...(pick.never_expires ? { never_expires: true } : {}),
     ...(pick.until_needs_year ? { until_needs_year: pick.until_needs_year } : {}),
+    ...(pick.verified ? { verified: pick.verified } : {}),
   };
 }
 
@@ -1078,6 +1089,7 @@ function pickWorkers(pick) {
     ...(pick.prep ? { prep: pick.prep } : {}),
     until: pick.until,
     ...(pick.never_expires ? { never_expires: true } : {}),
+    ...(pick.verified ? { verified: pick.verified } : {}),
     ...(pick.line ? { line: pick.line } : {}),
   }];
   if (pick.backup) {
@@ -1383,6 +1395,7 @@ function workerLineText(worker) {
   if (Number(worker.max_seconds) > 0) parts.push(`max: ${rosterMaxText(worker.max_seconds).replace(/^max /, '')}`);
   if (worker.prep) parts.push(`prep: ${rosterJobLabel(worker.prep)}`);
   if (worker.until) parts.push(`until ${worker.until}`);
+  if (worker.verified) parts.push(`verified ${worker.verified}`);
   return `- ${parts.join(', ')}`;
 }
 

package/lib/known-commands.js

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

package/lib/member-identity.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// How a launch names the member it runs as, in one place. The writers use
+// these lines and the team view reads them back with patterns built from the
+// same lines, so the wording cannot drift apart.
+//
+// Mission ticks (atris member run, atris mission) say:
+//   You are the member "validator".
+//   **Objective:** <what the run is for>
+// Dispatch briefs say:
+//   You are acting as validator. <the work>
+
+const escapeRegExp = require('./escape-regexp');
+
+const NAME = '([a-z0-9][a-z0-9_-]*[a-z0-9])';
+const SLOT = '\u0000';
+
+function memberIdentityLine(name) {
+  return `You are the member "${name}".`;
+}
+
+function missionObjectiveLine(objective) {
+  return `**Objective:** ${objective}`;
+}
+
+function patternFrom(line, name) {
+  return new RegExp(escapeRegExp(line).replace(escapeRegExp(SLOT), name), 'i');
+}
+
+const MISSION_MEMBER = patternFrom(memberIdentityLine(SLOT), NAME);
+const DISPATCH_MEMBER = /\bacting as (?:the )?([a-z0-9][a-z0-9_-]*[a-z0-9])[.,:;]?/i;
+const OBJECTIVE = patternFrom(missionObjectiveLine(SLOT), '(.+?)(?=\\s\\*\\*[A-Z][^*]*:\\*\\*|\\s#|$)');
+
+// One prompt -> { member, doing }. The member is the name the prompt runs
+// as, or null. doing is what the run is for: a mission's objective, or the
+// words after the dispatch line.
+function readMemberLaunch(prompt) {
+  const text = String(prompt || '').replace(/\\0?12|\\n/g, ' ').replace(/\s+/g, ' ').trim();
+  const mission = MISSION_MEMBER.exec(text);
+  if (mission) {
+    const objective = OBJECTIVE.exec(text);
+    return { member: mission[1].toLowerCase(), doing: objective ? objective[1].trim() : text };
+  }
+  const dispatch = DISPATCH_MEMBER.exec(text);
+  if (dispatch) {
+    const after = text.slice(dispatch.index + dispatch[0].length).trim();
+    return { member: dispatch[1].toLowerCase(), doing: after || text };
+  }
+  return { member: null, doing: text };
+}
+
+module.exports = {
+  memberIdentityLine,
+  missionObjectiveLine,
+  readMemberLaunch,
+};

package/lib/roster-models.js

@@ -97,6 +97,16 @@ function engineRunsView(engineId, { model = '', effort = '' } = {}, options = {}
   return view;
 }
 
+// "<engine> · <model label>" for a table cell: the tool, a middle dot, and the
+// model label, or "own default" when the tool picks its model itself.
+// Effort is left out; tables give it its own line.
+function engineModelText(engine, model = '') {
+  const id = String(engine || '').trim();
+  if (!id) return '';
+  const label = model ? modelLabel(model) : '';
+  return `${id} · ${label || 'own default'}`;
+}
+
 function runsDetail(view) {
   const items = [{ text: view.model ? modelLabel(view.model) : 'its own default', source: view.model ? view.model_source : 'roster' }];
   if (view.effort) items.push({ text: view.effort, source: view.effort_source });
@@ -172,6 +182,7 @@ function availableModels(engines, options = {}) {
 }
 
 module.exports = {
+  engineModelText,
   modelLabel,
   readCodexSettings,
   engineRunsView,