atris 3.82.17 → 3.82.19

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

package/lib/runs-on.js

@@ -0,0 +1,131 @@
+'use strict';
+
+// Where a team member does its work: "runs on" on a team line.
+//
+//   - cosmo: claude, on: atris computer
+//   - amara: on: grok bot
+//
+// Three kinds of place:
+//   local           this machine, shown by its own name ("Studio Mac mini")
+//   atris computer  the computer Atris hosts for the person or business
+//   anything else   a named bot on another machine ("grok bot", "claude duet")
+//
+// Naming an engine installed here ("on: muse") means that engine, locally.
+// Only local members run here; the rest wait for their own machine.
+//
+// The other machine knows it is that place through ATRIS_RUNS_AS, a comma
+// list of the names it answers to: ATRIS_RUNS_AS="grok bot" on the Grok bot's
+// computer, ATRIS_RUNS_AS="atris computer" on the hosted one. Scheduled jobs
+// rarely see shell settings, so the same list can live in ~/.atris/RUNS_AS
+// (one line). A member seated there runs there and nowhere else.
+
+const os = require('os');
+const { execFileSync } = require('child_process');
+
+const LOCAL_WORDS = new Set(['', 'local', 'here', 'this mac', 'this computer', 'this machine', 'my mac', 'my laptop', 'mac', 'laptop']);
+const ATRIS_COMPUTER_WORDS = new Set(['atris computer', 'atris cloud', 'cloud', 'computer', 'atris', 'your atris computer', 'business computer', 'personal computer', 'cloud computer']);
+const ATRIS_COMPUTER = 'atris computer';
+const KNOWN_LABELS = Object.freeze({
+  'atris computer': 'Atris computer',
+  'grok bot': 'Grok bot',
+  'claude duet': 'Claude Duet',
+  dots: 'Dots',
+  hermes: 'Hermes',
+  muse: 'Muse',
+});
+
+let cachedMachineName = null;
+
+// The name a person gave this machine, the one AirDrop shows. Falls back to
+// the host name without its .local tail.
+function machineName() {
+  if (cachedMachineName !== null) return cachedMachineName;
+  let name = '';
+  if (process.env.ATRIS_MACHINE_NAME) name = process.env.ATRIS_MACHINE_NAME;
+  if (!name && process.platform === 'darwin') {
+    try {
+      name = execFileSync('scutil', ['--get', 'ComputerName'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 }).trim();
+    } catch { name = ''; }
+  }
+  if (!name) name = String(os.hostname() || '').replace(/\.local$/i, '');
+  cachedMachineName = name || 'this computer';
+  return cachedMachineName;
+}
+
+// The place names this machine answers to, besides its own name.
+function runsAsNames() {
+  let list = process.env.ATRIS_RUNS_AS;
+  if (list === undefined) {
+    try {
+      list = require('fs').readFileSync(require('path').join(os.homedir(), '.atris', 'RUNS_AS'), 'utf8').split(/\r?\n/)[0];
+    } catch { list = ''; }
+  }
+  return String(list || '')
+    .split(',')
+    .map((name) => cleanWords(name))
+    .filter(Boolean)
+    .map((name) => (ATRIS_COMPUTER_WORDS.has(name) ? ATRIS_COMPUTER : name));
+}
+
+function cleanWords(text) {
+  return String(text || '')
+    .replace(/[‘’]/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function placeLabel(id) {
+  if (KNOWN_LABELS[id]) return KNOWN_LABELS[id];
+  return id.charAt(0).toUpperCase() + id.slice(1);
+}
+
+// What "on: <words>" means. isEngine(name) answers whether the words name an
+// engine atris knows; it is passed in so this file stays free of the
+// registry. Throws a plain sentence on words that cannot be a place.
+function readRunsOn(words, options = {}) {
+  const raw = String(words || '').trim();
+  const clean = cleanWords(raw);
+  if (/[,:]/.test(clean)) throw new Error(`"${raw}" is not a place; use on: atris computer, on: local, or a bot name like on: grok bot`);
+  if (clean.length > 40) throw new Error(`"${raw}" is too long for a place name`);
+  if (LOCAL_WORDS.has(clean) || clean === cleanWords(machineName())) {
+    return { id: 'local', label: machineName(), here: true };
+  }
+  const answersTo = runsAsNames();
+  if (ATRIS_COMPUTER_WORDS.has(clean)) return { id: ATRIS_COMPUTER, label: placeLabel(ATRIS_COMPUTER), here: answersTo.includes(ATRIS_COMPUTER) };
+  const engine = typeof options.isEngine === 'function' ? options.isEngine(clean) : '';
+  if (engine) return { id: 'local', label: machineName(), here: true, engine };
+  return { id: clean, label: placeLabel(clean), here: answersTo.includes(clean) };
+}
+
+// The "on:" part of a team line value, split off so the rest reads exactly
+// as it always did. Returns { rest, on } where on is the words after "on:"
+// or '' when the line names no place.
+function splitRunsOn(value) {
+  const parts = String(value || '').split(',').map((part) => part.trim()).filter(Boolean);
+  let on = '';
+  const rest = [];
+  for (const part of parts) {
+    const match = /^on\s*:\s*(.*)$/i.exec(part);
+    if (match && !on) on = match[1].trim() || 'local';
+    else if (match) throw new Error('names two places; keep one on: part');
+    else rest.push(part);
+  }
+  return { rest: rest.join(', '), on };
+}
+
+// The "runs on" text a table shows for one member.
+function runsOnText(place, engineId) {
+  if (!place || place.here) {
+    const where = place && place.label ? place.label : machineName();
+    return engineId ? `${engineId} on ${where}` : where;
+  }
+  return place.label;
+}
+
+module.exports = {
+  machineName,
+  readRunsOn,
+  splitRunsOn,
+  runsOnText,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.17",
+  "version": "3.82.19",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",