atris 3.82.18 → 3.82.20

package/commands/mission.js

@@ -8217,6 +8217,9 @@ function detectUnavailableModel(text) {
 // need a resume; a model-unavailable pause is a config error a bare resume won't fix,
 // so name the dead id and the two knobs that change it.
 function missionPauseNextAction(pauseReason, missionId, deadModel = null, lastErrorReason = null) {
+  if (pauseReason === 'member-runs-elsewhere') {
+    return 'left for the machine its owner works on; to run it here, move the owner back: atris engine roster set --member <name> --on local';
+  }
   if (pauseReason === 'protected-lane-review') {
     return `review the protected diff and its receipt before resuming: atris mission run ${missionId}`;
   }
@@ -9577,6 +9580,11 @@ async function executeMissionRunTicksPhase(context) {
       let cachedStep = findCachedMissionStepReceipt(cwd, { missionId: mission.id, tickIndex: tickIdx });
       let cachedVerifierResult = cachedStep ? cachedStep.verifier_result : null;
       const tickSelection = resolveMissionTickRunner(runtimeMission, cwd);
+      if (tickSelection.runs_elsewhere) {
+        console.error(`${mission.owner} runs on ${tickSelection.runs_elsewhere}, so this machine leaves the work for it.`);
+        pauseReason = 'member-runs-elsewhere';
+        break;
+      }
       const tickRuntimeMission = tickSelection.mission;
       const tickRunnerName = String(tickRuntimeMission.runner || '').trim().toLowerCase();
       const tickCallerSessionRunner = runnerUsesCallerSession(tickRunnerName);
@@ -10406,7 +10414,9 @@ function completeMissionRunPhase(context) {
     // 'no-progress' is a clean stop the run diagnosed itself, never route it
     // through handleMissionBlocker (that would file a blocker task and
     // dispatch an engine to "fix" a mission that correctly stopped itself).
-    const blockerReason = ['no-progress', 'budget-exhausted'].includes(pauseReason)
+    // 'member-runs-elsewhere' is the same: the owner's own machine does the
+    // work, so nothing here is broken and nothing local should "fix" it.
+    const blockerReason = ['no-progress', 'budget-exhausted', 'member-runs-elsewhere'].includes(pauseReason)
       ? null
       : (pauseReason || mission.stop_reason || (mission.status === 'blocked' ? 'verifier-failed' : null));
     if (selfDrive && blockerReason) {

package/commands/probe.js

@@ -59,14 +59,58 @@ function normalizeBash(cmd, label) {
   return cmd.split(l + '/').join('').split(l).join('.');
 }
 
-// No write/edit file ops, and the `..` guard only covers args.path. The
-// `bash` op still executes whatever command the model sends, verbatim, on
-// the remote ai-computer, that is the production relay contract and the
-// table must stay in lockstep with it, so this probe is NOT read-only.
+// Every file op the server's local_file_op offers: the enum of LOCAL_FILE_TOOL
+// in the backend (backend/rl/tool_policy_bench.py). The backend test
+// test_local_file_op_probe_lockstep.py pins that enum to this list, so the
+// server cannot add an op without that test failing until this table and
+// SERVER_FILE_OPS are updated together. test/probe-file-ops.test.js fails if
+// any op listed here has no command below.
+const SERVER_FILE_OPS = ['list', 'search', 'glob', 'inspect', 'read', 'write', 'append', 'edit', 'bash'];
+
+// Directory names the server hides from glob unless include_generated is set
+// (IGNORED_WORKSPACE_PARTS in the same backend file).
+const IGNORED_PARTS = ['.git', '.next', '.pytest_cache', '.venv', '__pycache__', 'build', 'dist', 'node_modules', 'release', 'venv'];
+
+// The `..` guard. It covers args.path and, for the ops that take more than one
+// path, every `paths` entry and the glob pattern. The `bash` op still executes
+// whatever command the model sends, verbatim, on the remote ai-computer, that
+// is the production relay contract and the table must stay in lockstep with
+// it, so this probe is NOT read-only.
+function hasParentRef(value) {
+  return String(value).split('/').includes('..');
+}
+
+function boundedInt(value, fallback, low, high) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(Math.max(parsed, low), high);
+}
+
+function b64(value) {
+  return Buffer.from(String(value), 'utf8').toString('base64');
+}
+
+// Same edit the server runs (_python_edit_command): replace the first match.
+const PY_EDIT = 'import base64,pathlib,sys;'
+  + 'p=pathlib.Path(sys.argv[1]);text=p.read_text(encoding=\'utf-8\');'
+  + 'old=base64.b64decode(sys.argv[2]).decode(\'utf-8\');'
+  + 'new=base64.b64decode(sys.argv[3]).decode(\'utf-8\');'
+  + 'old in text or sys.exit(\'find text not found\');'
+  + 'p.write_text(text.replace(old,new,1),encoding=\'utf-8\')';
+
+// glob like the server's pathlib glob: `**` recurses, hidden files match,
+// directories end in `/`, generated directories are hidden unless asked for.
+const PY_GLOB = 'import glob,os,pathlib,sys\n'
+  + 'pat,limit,gen,ign=sys.argv[1],int(sys.argv[2]),sys.argv[3]==\'1\',sys.argv[4].split(\',\')\n'
+  + 'raw=map(str,pathlib.Path(\'.\').glob(pat)) if not os.path.isabs(pat) else glob.glob(pat,recursive=True)\n'
+  + 'hits=sorted({h+(\'/\' if os.path.isdir(h) else \'\') for h in raw if gen or not any(x in ign for x in h.split(\'/\'))})\n'
+  + 'print(\'\\n\'.join(hits[:limit]))\n'
+  + 'len(hits)>limit and print(\'[%d more match(es) not shown]\'%(len(hits)-limit))';
+
 function fileOpCommand(args, label) {
   const op = String(args.type || '').toLowerCase();
   const raw = normalizePath(String(args.path || '') || '.', label);
-  if (raw.split('/').includes('..')) return null;
+  if (hasParentRef(raw)) return null;
   const p = shq(raw);
   if (op === 'bash') return `( ${normalizeBash(String(args.command || '') || 'true', label)} )`;
   if (op === 'list') return `find ${p} -maxdepth 3 -not -path '*/node_modules/*' -not -path '*/.git/*' | head -200`;
@@ -74,7 +118,42 @@ function fileOpCommand(args, label) {
     const q = shq(String(args.query || args.pattern || ''));
     return `grep -rn -m 50 ${q} ${p} 2>/dev/null | head -50`;
   }
+  // The server's read with a wildcard (*, ?, [) is a glob.
+  if (op === 'read' && /[*?[]/.test(raw)) return fileOpCommand({ ...args, type: 'glob', pattern: raw }, label);
   if (op === 'read') return `{ [ -d ${p} ] && ls -p ${p} | head -200 || head -c 12000 ${p}; }`;
+  if (op === 'glob') {
+    const pattern = normalizePath(String(args.pattern || args.query || args.path || '').trim(), label);
+    if (!pattern || hasParentRef(pattern)) return null;
+    const limit = boundedInt(args.max_results, 200, 1, 1000);
+    return `python3 -c ${shq(PY_GLOB)} ${shq(pattern)} ${limit} ${args.include_generated ? 1 : 0} ${shq(IGNORED_PARTS.join(','))}`;
+  }
+  if (op === 'inspect') {
+    const depth = boundedInt(args.max_depth, 2, 1, 4);
+    const limit = boundedInt(args.max_results, 80, 1, 300);
+    const rawPaths = args.paths;
+    const listed = Array.isArray(rawPaths)
+      ? rawPaths.map((item) => String(item).trim()).filter(Boolean)
+      : String(rawPaths || '').split(',').map((item) => item.trim()).filter(Boolean);
+    const reads = listed.slice(0, 8).map((item) => normalizePath(item, label));
+    if (reads.some(hasParentRef)) return null;
+    const pieces = [`find ${p} -mindepth 1 -maxdepth ${depth} -print | head -${limit}`];
+    for (const rel of reads) pieces.push(`printf '\\n== %s ==\\n' ${shq(rel)}; head -c 12000 ${shq(rel)}`);
+    const verify = String(args.command || '').trim();
+    if (verify) pieces.push(`( ${normalizeBash(verify, label)} )`);
+    return pieces.join('; ');
+  }
+  if (op === 'write' || op === 'append') {
+    // A write needs a real file path and its content. The server writes an
+    // empty file when content is missing; a probe call like that is malformed.
+    if (!String(args.path || '').trim() || raw === '.' || typeof args.content !== 'string') return null;
+    const parent = shq(path.posix.dirname(raw));
+    return `mkdir -p -- ${parent} && printf %s ${shq(b64(args.content))} | base64 -d ${op === 'append' ? '>>' : '>'} ${p}`;
+  }
+  if (op === 'edit') {
+    const find = String(args.find || '');
+    if (!String(args.path || '').trim() || raw === '.' || !find) return null;
+    return `python3 -c ${shq(PY_EDIT)} ${p} ${b64(find)} ${b64(args.replace || '')}`;
+  }
   return null;
 }
 
@@ -95,6 +174,16 @@ const SIMPLE_CLI_OPS = {
   mission_status: ['mission', 'status', '--json'],
 };
 
+// Things the server relays or offers that this harness does not run. A model
+// that uses one gets an error back and the probe reports "probe limit", which
+// says the harness could not vouch for that call, not that the product broke.
+// Anything the server never offers (an invented op or tool) stays a failure.
+const NOT_RUN_CLI_OPS = new Set([
+  'apps_list', 'atris_search', 'imessage_doctor', 'imessage_latest',
+  'task_create', 'task_update', 'skill_audit', 'codex_goal_status',
+]);
+const NOT_RUN_TOOLS = new Set(['dispatch_scout']);
+
 function atrisCliCommand(args) {
   const op = String(args.type || '').toLowerCase();
   let argv = SIMPLE_CLI_OPS[op] || null;
@@ -269,6 +358,7 @@ async function runAtris2Turn(opts = {}) {
   let engine = null;
   const cliOps = [];
   const unsupported = [];
+  const limits = [];
 
   try {
     await new Promise((resolve, reject) => {
@@ -324,8 +414,8 @@ async function runAtris2Turn(opts = {}) {
               if (name === 'local_file_op') {
                 const cmd = fileOpCommand(args, label);
                 if (cmd === null) {
-                  out = { status: 'error', error: 'unsupported op or unsafe path' };
-                  unsupported.push(`file_op:${op}`);
+                  out = { status: 'error', error: SERVER_FILE_OPS.includes(op) ? 'refused: unsafe path or missing argument' : 'unsupported op' };
+                  unsupported.push(SERVER_FILE_OPS.includes(op) ? `file_op_refused:${op}` : `file_op:${op}`);
                 } else {
                   const term = localCwd
                     ? await runLocalTerminal(cmd, localCwd, localEnv || process.env, localPathPrefix)
@@ -344,7 +434,7 @@ async function runAtris2Turn(opts = {}) {
                 const cmd = atrisCliCommand(args);
                 if (cmd === null) {
                   out = { status: 'error', error: `unsupported atris cli op: ${op || '?'}` };
-                  unsupported.push(`cli_op:${op || '?'}`);
+                  (NOT_RUN_CLI_OPS.has(op) ? limits : unsupported).push(`cli_op:${op || '?'}`);
                 } else {
                   const term = localCwd
                     ? await runLocalTerminal(cmd, localCwd, localEnv || process.env, localPathPrefix)
@@ -354,7 +444,7 @@ async function runAtris2Turn(opts = {}) {
                 }
               } else {
                 out = { status: 'error', error: `unsupported relayed tool: ${name || '?'}` };
-                unsupported.push(`tool:${name || '?'}`);
+                (NOT_RUN_TOOLS.has(name) ? limits : unsupported).push(`tool:${name || '?'}`);
               }
               await postJson(`${base}/atris2/turn/tool-result`, token,
                 buildToolResultBody(ev.call_id || ev.id, out), 30000);
@@ -399,6 +489,8 @@ async function runAtris2Turn(opts = {}) {
   out.tools_run = toolsRun;
   out.cli_ops = cliOps;
   out.unsupported = unsupported;
+  // Only present when the harness skipped something, so the result keeps its old shape otherwise.
+  if (limits.length) out.limits = limits;
   out.error = err;
   out.ok = err === null;
   out.duration_ms = Date.now() - t0;
@@ -429,6 +521,7 @@ async function probeCommand(argv) {
   const err = turn.error;
   const engine = turn.engine;
   const unsupported = turn.unsupported;
+  const limits = turn.limits || [];
 
   // Name the dead-end (first match wins); null = converged.
   let deadEnd = null;
@@ -451,9 +544,12 @@ async function probeCommand(argv) {
   const secs = Math.round((Date.now() - t0) / 100) / 10;
   const ok = deadEnd === null;
   const stamp = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
-  const detail = ok
+  const limitNote = limits.length
+    ? ` · probe limit (this harness did not run it, not a product failure): ${limits.slice(0, 3).join(',')}`
+    : '';
+  const detail = (ok
     ? `answer: ${resultText.slice(0, 80).replace(/\n/g, ' ')}`
-    : `dead-end: ${deadEnd}`;
+    : `dead-end: ${deadEnd}`) + limitNote;
   const line = buildProbeLine({ stamp, where, model: a.model, member, engine, ok, secs, toolsRun, calendar: a.calendar, cliCalendarOps, detail });
   console.log(line);
   return ok ? 0 : 1;
@@ -477,6 +573,7 @@ module.exports = {
   normalizePath,
   normalizeBash,
   fileOpCommand,
+  SERVER_FILE_OPS,
   atrisCliCommand,
   atrisCliResult,
   runLocalTerminal,

package/lib/engine-ask.js

@@ -34,7 +34,7 @@ const MAX_ASK_PROMPT_BYTES = 16 * 1024;
 const MAX_ASK_TOTAL_PROMPT_BYTES = 64 * 1024;
 const MAX_ASK_OUTPUT_BYTES = 1024 * 1024;
 const ASK_STOP_GRACE_MS = 250;
-const ASK_MODEL_ENGINES = new Set(['claude', 'fable', 'haiku', 'codex', 'cursor', 'devin', 'grok', 'agy', 'opencode', 'commandcode']);
+const ASK_MODEL_ENGINES = new Set(['claude', 'fable', 'haiku', 'codex', 'cursor', 'devin', 'grok', 'muse', 'agy', 'opencode', 'commandcode']);
 const READ_ONLY_PREAMBLE = [
   'This is a read-only request.',
   'Do not modify files, create worktrees, start background agents, or run commands with side effects.',
@@ -324,6 +324,15 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '', {
       args: ['--no-memory', '--no-subagents', '--permission-mode', 'plan', '--sandbox', 'read-only', ...(model ? ['--model', model] : []), ...effortArgs, '-p', request],
     };
   }
+  if (engine === 'muse') {
+    // --disable-write blocks file edits; the read-only preamble covers the
+    // shell. Network stays on so a question can read atris memory.
+    return {
+      engine,
+      bin: profile.bin,
+      args: ['exec', '--sandbox-network', 'enabled', '--disable-write', ...(model ? ['--model', model] : []), request],
+    };
+  }
   if (engine === 'agy') {
     // agy prompts for tool permission even in plan mode and a headless ask
     // has no one to answer, so it denies itself `ls` and fails every ask

package/lib/engine-processes.js

@@ -54,6 +54,10 @@ const ENGINE_FLAGS = {
     values: ['--permission-mode', '--sandbox', '--reasoning-effort', '--best-of-n'],
     switches: ['--always-approve', '--no-memory', '--no-subagents'],
   },
+  muse: {
+    values: ['--sandbox-network', '--model', '--approval-mode', '--permission-profile'],
+    switches: ['--trust-workspace', '--disable-write', '--disable-approval', '--disable-sandbox', '--yolo'],
+  },
   agy: {
     values: ['--mode', '--print-timeout'],
     switches: ['--sandbox', '--dangerously-skip-permissions'],
@@ -105,6 +109,7 @@ const RUN_RULES = {
   cursor: (split) => printing(split) || split.prompt.length > 0,
   devin: printing,
   grok: printing,
+  muse: ({ command }) => command[0] === 'exec',
   agy: printing,
   opencode: ({ command }) => command[0] === 'run',
   'atris-fast': ({ flags, prompt }) => !flags.some(([name]) => AX_CONTROL_FLAGS.has(name)) && prompt.length > 0,
@@ -114,7 +119,7 @@ const RUN_RULES = {
 
 // Subcommand words ahead of the settings.
 function subcommandCount(engine, args) {
-  if (engine === 'codex' || engine === 'droid' || engine === 'opencode') return 1;
+  if (engine === 'codex' || engine === 'droid' || engine === 'opencode' || engine === 'muse') return 1;
   if (engine === 'atris') return args[0] === 'engine' ? 2 : 1;
   return 0;
 }
@@ -138,7 +143,7 @@ function canonicalEngine(name) {
 
 // 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',
+  claude: 'claude', 'cursor-agent': 'cursor', droid: 'droid', devin: 'devin', grok: 'grok', muse: 'muse', agy: 'agy', opencode: 'opencode',
   ax: 'atris-fast', cmd: 'commandcode', atris: 'atris',
 });
 

package/lib/engine-registry.js

@@ -174,6 +174,10 @@ const ENGINE_SEED_META = Object.freeze({
   // Devin gathers context for search only when a roster picks it.
   devin: Object.freeze({ tier: 'max', roles: Object.freeze(['executor']), roster_only_roles: Object.freeze(['navigator']), models: Object.freeze(['built-in router']), duty: 'errands', fallback_order: 40 }),
   grok: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['grok 4.7 fast', 'grok 4.7']), fallback_order: 45 }),
+  // Muse runs only Meta's Muse models. The router hands it build work last,
+  // after every engine with a longer record here; a roster pick may also give
+  // it search or review, so a member seat can sit on Muse whatever its job.
+  muse: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), roster_only_roles: Object.freeze(['navigator', 'validator']), models: Object.freeze(['muse-wonder-1.0', 'muse-spark-1.3']), fallback_order: 97 }),
   fable: Object.freeze({ tier: 'max', roles: Object.freeze(['validator', 'executor']), models: Object.freeze(['opus 5.5', 'opus 5', 'fable', 'haiku']), duty: 'leader', fallback_order: 50 }),
   composer: Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator', 'executor']), models: Object.freeze(['composer 2.5']), fallback_order: 60, hosted: true }),
   haiku: Object.freeze({ tier: 'fast', roles: Object.freeze(['validator', 'navigator']), role_order: Object.freeze({ navigator: 5 }), models: Object.freeze(['haiku']), fallback_order: 70 }),
@@ -865,6 +869,7 @@ function resolveEngineModelWords(text) {
   }
   if (/^(opus|sonnet|haiku|fable|opusplan)\b/.test(lower)) return { engine: 'claude', model: model('claude', clean) };
   if (/^grok/.test(lower)) return { engine: 'grok', model: model('grok', clean) };
+  if (/^muse-/.test(lower)) return { engine: 'muse', model: model('muse', clean) };
   if (/^swe-/.test(lower)) return { engine: 'devin', model: clean };
   if (/^gemini-/.test(lower)) return { engine: 'agy', model: clean };
   throw new Error(`"${clean}" is not an engine or a model atris knows`);
@@ -933,7 +938,10 @@ function rosterPickFromValue(value, role, options = {}) {
     const effortMatch = /^effort\s*(?::\s*|\s+)(.+)$/i.exec(part);
     const prepMatch = /^prep\s*(?::\s*|\s+)(.+)$/i.exec(part);
     const verifiedMatch = /^verified\s+(.+)$/i.exec(part);
-    if (verifiedMatch && !verified) {
+    if (/^on\s*:/i.test(part)) {
+      // "on: atris computer": where the member works. Read with the team
+      // line in member-engine.js; it does not change the engine pick.
+    } else 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();
@@ -1816,14 +1824,60 @@ function setTeamPick(memberName, engineName, options = {}, root = process.cwd())
   const base = existing !== null ? sectionedRosterText(existing, file, { ...options, root }) : rosterMarkdownFromPicks(layer.picks);
   // a swap changes only the lead of the member's line already in this file
   const line = scanRosterMarkdown(base).entries.find((entry) => entry.section === 'team' && !entry.malformed && entry.name.trim().toLowerCase() === member);
-  const value = (line && teamValueWithLead(line.value, engineId, model, role, { root }))
+  // the member's place ("on: grok bot") stays when its engine changes
+  const { splitRunsOn } = require('./runs-on');
+  const kept = line ? splitRunsOn(line.value) : { rest: '', on: '' };
+  // read the line without its place, wherever the on: part sits
+  let value = (kept.rest && teamValueWithLead(kept.rest, engineId, model, role, { root }))
     || workerLineText({ engine: engineId, model }).replace(/^-\s+/, '');
+  if (kept.on && !splitRunsOn(value).on) value = `${value}, on: ${kept.on}`;
   rosterPickFromValue(value, role, { root });
   writeAtomic(file, replaceTeamLine(base, member, value));
   if (target.scope === 'session') sweepStaleSessionRosters(options);
   return { member, engine: engineId, model, value, scope: target.scope, file };
 }
 
+// Throws the plain sentence setTeamPlace would, before anything is written.
+function setTeamPlaceCheck(placeWords) {
+  const { readRunsOn } = require('./runs-on');
+  return readRunsOn(placeWords, { isEngine: (words) => canonicalEngineName(words) });
+}
+
+// Say where one member works: "atris computer", "local", or a bot on another
+// machine ("grok bot"). The rest of the member's line stays as written. Local
+// drops the on: part, since local is what a line with no place means.
+function setTeamPlace(memberName, placeWords, options = {}, root = process.cwd()) {
+  const { replaceTeamLine, scanRosterMarkdown } = require('./roster-markdown');
+  const { readRunsOn, splitRunsOn } = require('./runs-on');
+  const member = String(memberName || '').trim().toLowerCase();
+  if (!/^[a-z0-9._-]+$/.test(member)) throw new Error(`"${memberName}" is not a member name`);
+  const place = readRunsOn(placeWords, { isEngine: (words) => canonicalEngineName(words) });
+  const target = rosterWriteTarget(options, root);
+  const registry = readEngineRegistry(root, { persist: false });
+  const layer = target.layer || readProjectRoster(root, { ...options, registry });
+  const file = target.file;
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+  const base = existing !== null ? sectionedRosterText(existing, file, { ...options, root }) : rosterMarkdownFromPicks(layer.picks);
+  const line = scanRosterMarkdown(base).entries.find((entry) => entry.section === 'team' && !entry.malformed && entry.name.trim().toLowerCase() === member);
+  const old = line ? splitRunsOn(line.value) : { rest: '', on: '' };
+  let rest = old.rest;
+  // "on: muse" named the engine through its place; moving keeps that engine
+  if (!rest && old.on) {
+    const before = readRunsOn(old.on, { isEngine: (words) => canonicalEngineName(words) });
+    if (before.engine) rest = rosterToolLabel(before.engine);
+  }
+  const value = place.here
+    ? (rest || (place.engine ? rosterToolLabel(place.engine) : 'on: local'))
+    : [rest, `on: ${place.id}`].filter(Boolean).join(', ');
+  if (place.here && place.engine && rest) {
+    // "on: muse" on a line that already names an engine: the engine changes
+    return { ...setTeamPick(member, place.engine, options, root), place };
+  }
+  writeAtomic(file, replaceTeamLine(base, member, value));
+  if (target.scope === 'session') sweepStaleSessionRosters(options);
+  return { member, value, place, scope: target.scope, file };
+}
+
 function renewRoster(roster, date) {
   const next = { ...(roster || {}) };
   for (const key of [...ENGINE_ROLES, ...customRosterJobKeys(next)]) {
@@ -2452,6 +2506,8 @@ module.exports = {
   customRosterJobKeys,
   setRosterPick,
   setTeamPick,
+  setTeamPlace,
+  setTeamPlaceCheck,
   confirmRoster,
   engineHasRole,
   engineHosted,

package/lib/fleet.js

@@ -1866,7 +1866,7 @@ module.exports = {
 // Engines that can edit a repo headlessly. atris-fast (ax) is a chat lane,
 // not a repo worker, it keeps owning normal mission ticks, not fleet builds.
 const FLEET_CAPABLE = ['claude', 'codex', 'cursor', 'devin', 'grok'];
-const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable', 'commandcode'];
+const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable', 'commandcode', 'muse'];
 
 let receiptSequence = 0;
 function nowStamp() {

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', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'sentinel', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'growth', 'scorecard', 'rating', 'sync-checkout', 'zen',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'film', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'google', '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', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an

package/lib/member-engine.js

@@ -6,6 +6,8 @@
 // builds. A line under "## team" in ROSTER.md overrides that, either with a
 // job ("researcher: search", "fixer: small build") or with engine or model
 // words ("judge: opus"). The job's pick then comes from the roster.
+// An "on:" part says where the member works ("on: atris computer",
+// "on: grok bot"); only a member that runs here gets an engine here.
 
 const fs = require('fs');
 const { memberRefusalReason } = require('./member-type');
@@ -28,6 +30,20 @@ const {
   rosterPickFromValue,
 } = require('./engine-registry');
 const { isParkedText } = require('./member-park');
+const { readRunsOn, splitRunsOn, machineName } = require('./runs-on');
+
+// The engine id words name, or '' when they name none atris knows.
+function engineNamed(words) {
+  try {
+    return require('./engine-registry').canonicalEngineName(words) || '';
+  } catch { return ''; }
+}
+
+// The place one team line names, or local when it names none.
+function placeFromOn(on) {
+  if (!on) return { id: 'local', label: machineName(), here: true };
+  return readRunsOn(on, { isEngine: engineNamed });
+}
 
 const SEARCH_WORDS = Object.freeze(['navigator', 'researcher', 'research', 'search', 'scout']);
 const REVIEW_WORDS = Object.freeze(['validator', 'reviewer', 'review', 'judge', 'critic', 'verifier']);
@@ -111,17 +127,27 @@ function teamLineFor(state, member) {
 // member's own kind of work. error is a plain sentence for a line that means
 // neither.
 function interpretTeamValue(value, state, memberKind, options = {}) {
-  const text = String(value || '').trim();
-  if (!text) return { error: 'names no job or engine' };
+  let split;
+  let place;
+  try {
+    split = splitRunsOn(value);
+    place = placeFromOn(split.on);
+  } catch (error) {
+    return { error: error.message };
+  }
+  // "on: muse" with nothing else: that engine, here.
+  const text = split.rest || (place.engine || '');
+  if (!text) return split.on ? { type: 'place', place } : { error: 'names no job or engine' };
   const key = rosterJobKey(text);
-  if (key && ENGINE_ROLES.includes(key)) return { type: 'job', key };
+  if (key && ENGINE_ROLES.includes(key)) return { type: 'job', key, place };
   const saved = (layer) => Boolean(key && layer && layer.picks && layer.picks[key]);
-  if (saved(state.session) || saved(state.project) || saved(state.machine)) return { type: 'job', key };
+  if (saved(state.session) || saved(state.project) || saved(state.machine)) return { type: 'job', key, place };
   try {
-    return { type: 'pick', pick: rosterPickFromValue(text, ENGINE_JOBS[memberKind], options) };
+    return { type: 'pick', pick: rosterPickFromValue(text, ENGINE_JOBS[memberKind], options), place };
   } catch (error) {
-    if (key && inferJobKind(text)) return { type: 'job', key };
-    return { error: error.message };
+    if (key && inferJobKind(text)) return { type: 'job', key, place };
+    // the engine part does not read, but the place still counts
+    return { error: error.message, place };
   }
 }
 
@@ -143,6 +169,7 @@ function resolveEngineForMember(memberName, root = process.cwd(), options = {})
   const read = line ? interpretTeamValue(line.value, state, autoKind, options) : null;
   const override = read && !read.error ? read : null;
   const yearless = override && override.type === 'pick' && override.pick.until_needs_year;
+  const place = read && read.place ? read.place : placeFromOn('');
   const pickOptions = {
     ...options,
     sessionRosterPicks: state.session ? state.session.picks : {},
@@ -156,6 +183,9 @@ function resolveEngineForMember(memberName, root = process.cwd(), options = {})
     source: override ? 'file' : 'auto',
     file: override ? line.file : null,
     line: override ? line.line : null,
+    runs_on: place.id,
+    runs_on_label: place.label,
+    runs_here: place.here,
     ...(read && read.error ? { warning: read.error } : {}),
     ...(yearless ? { until_warning: `has no year in its until date, so it counts as expired; write until ${yearless}` } : {}),
   };
@@ -187,6 +217,7 @@ function resolveEngineForMember(memberName, root = process.cwd(), options = {})
   const fromRoster = rosterDecided(resolved.source);
   return {
     ...base,
+    ...(override && override.type === 'place' ? { source: 'file', file: line.file, line: line.line } : {}),
     job,
     job_key: jobKey,
     role,
@@ -214,6 +245,24 @@ function memberRosterEngine(memberName, root = process.cwd(), options = {}) {
   }
 }
 
+// The place a member works when it is not this machine ("Grok bot",
+// "Atris computer"), or '' when it runs here. Never throws: a broken roster
+// must not stop a run.
+function memberRunsElsewhere(memberName, root = process.cwd(), options = {}) {
+  const name = String(memberName || '').trim();
+  if (!name || name.includes('/') || name.includes('\\')) return '';
+  try {
+    // only the member's place is read: no engine is resolved, so nothing is
+    // printed or probed for a member that works here
+    const line = teamLineFor(options.rosterState || readRosterState(root, options), name);
+    if (!line) return '';
+    const place = placeFromOn(splitRunsOn(line.value).on);
+    return place.here ? '' : place.label || place.id;
+  } catch {
+    return '';
+  }
+}
+
 // A person or odd-typed card never runs on an engine.
 function memberCardRunnable(root, name) {
   const card = findMemberCard(root, name);
@@ -254,13 +303,19 @@ function teamRosterView(root = process.cwd(), options = {}) {
       warnings.push({ file: line.file, line: line.line, text: line.text, message: `${picked.warning}, so ${name} picks automatically` });
     }
     if (picked.until_warning && line) warnings.push({ file: line.file, line: line.line, text: line.text, message: picked.until_warning });
+    // A member working on another machine runs whatever that machine runs,
+    // unless its line names the engine; this machine's router has no say.
+    const theirs = picked.runs_here === false && picked.pick_source !== 'team';
     return {
       member: name,
       job: picked.job,
-      engine: picked.engine ? picked.engine.id : null,
-      model: picked.model || null,
+      engine: picked.engine && !theirs ? picked.engine.id : null,
+      model: theirs ? null : picked.model || null,
       effort: picked.engine && picked.engine.roster_effort ? picked.engine.roster_effort : null,
       max_seconds: picked.engine && picked.engine.roster_max_seconds ? picked.engine.roster_max_seconds : null,
+      runs_on: picked.runs_on,
+      runs_on_label: picked.runs_on_label,
+      runs_here: picked.runs_here,
       source: picked.source,
       file: picked.file,
       reason: picked.reason,
@@ -271,8 +326,10 @@ function teamRosterView(root = process.cwd(), options = {}) {
 
 module.exports = {
   autoJobForMember,
+  teamLineFor,
   readMemberCard,
   resolveEngineForMember,
   memberRosterEngine,
+  memberRunsElsewhere,
   teamRosterView,
 };

package/lib/mission-core.js

@@ -361,6 +361,13 @@ function memberLogTickReason(result) {
 }
 
 function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
+  // A member whose team line says it works on another machine is left for
+  // that machine, whatever engine the mission names; this one never runs
+  // its work in its place.
+  if (mission && mission.owner) {
+    const elsewhere = require('./member-engine').memberRunsElsewhere(mission.owner, root, options);
+    if (elsewhere) return { mission, engine_id: null, requested_engine: null, engine_fallback_reason: null, runs_elsewhere: elsewhere };
+  }
   if (String(mission && mission.runner || '').trim().toLowerCase() !== MISSION_AUTO_RUNNER) {
     // A named engine still gets the roster's time limit for that engine.
     const runner = String(mission && mission.runner || '').trim().toLowerCase();

package/lib/model-names.js

@@ -32,6 +32,18 @@ function normalizeGrokModel(raw) {
   throw new Error(`grok does not know the model "${raw}". use grok 4.7 fast, grok 4.7, or a full grok- id`);
 }
 
+// Muse takes friendly names: "muse wonder" is muse-wonder-1.0, "spark 1.3"
+// is muse-spark-1.3. Any full muse- id passes through as typed.
+const MUSE_MODEL_SPELLING = /^(?:muse[\s_-]*)?(wonder|spark)(?:[\s_-]*(\d+(?:\.\d+)?))?$/;
+const MUSE_DEFAULT_VERSIONS = Object.freeze({ wonder: '1.0', spark: '1.3' });
+
+function normalizeMuseModel(raw) {
+  const match = MUSE_MODEL_SPELLING.exec(raw.toLowerCase());
+  if (match) return `muse-${match[1]}-${match[2] || MUSE_DEFAULT_VERSIONS[match[1]]}`;
+  if (/^muse-[a-z0-9][a-z0-9._-]*$/i.test(raw)) return raw;
+  throw new Error(`muse does not know the model "${raw}". use muse wonder, muse spark, or a full muse- id`);
+}
+
 // The model to run for a claude id: its replacement when it is retired,
 // else the id as given. Keeps a "[1m]" tail.
 function currentClaudeModel(value) {
@@ -75,6 +87,7 @@ function normalizeRosterModel(engineId, value) {
   const raw = String(value || '').trim();
   if (!raw) return '';
   if (engineId === 'grok') return normalizeGrokModel(raw);
+  if (engineId === 'muse') return normalizeMuseModel(raw);
   if (!CLAUDE_FAMILY_ENGINES.includes(engineId)) return raw;
   // "[1m]" asks the claude cli for the long context window; keep it on
   // whatever name it follows.

package/lib/runner-command.js

@@ -120,6 +120,16 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     effortFlag: '--reasoning-effort',
     efforts: Object.freeze(['low', 'medium', 'high']),
   }),
+  // Meta's Muse Code. Its sandbox sends network through a proxy by default,
+  // which blocks atris calls; "enabled" keeps the sandbox and approval judge
+  // on and lets the run reach the network. Trusting the workspace loads its
+  // AGENTS.md rules. Muse runs only Muse models (verified 2026-11-11).
+  muse: Object.freeze({
+    bin: 'muse',
+    model: '',
+    ownModelsOnly: true,
+    commandTemplate: '{bin} exec --sandbox-network enabled --trust-workspace {pinnedModelFlag} {prompt}',
+  }),
   agy: Object.freeze({
     bin: 'agy',
     // No hard pin: the agy CLI keeps its own session model, so an unpinned