atris 3.82.18 → 3.82.20

package/atris/skills/engines/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: engines
-description: "Dispatch work to an installed terminal agent or named Atris engine profile. Supports Atris Fast, Claude, Codex, Cursor, Fable, Composer, Haiku, Devin, Grok, Antigravity (agy), and opencode. Triggers on: use codex, use cursor, use devin, use grok, use agy, use antigravity, use gemini, gemini session, use fable, use claude, use opencode, use atris, engine, dispatch to, worker agent, second opinion build."
+description: "Dispatch work to an installed terminal agent or named Atris engine profile. Supports Atris Fast, Claude, Codex, Cursor, Fable, Composer, Haiku, Devin, Grok, Muse, Antigravity (agy), and opencode. Triggers on: use codex, use cursor, use devin, use grok, use muse, use agy, use antigravity, use gemini, gemini session, use fable, use claude, use opencode, use atris, engine, dispatch to, worker agent, second opinion build."
 version: 1.7.0
 tags:
   - engines
@@ -12,6 +12,7 @@ tags:
   - haiku
   - devin
   - grok
+  - muse
   - agy
   - antigravity
   - gemini
@@ -22,7 +23,7 @@ tags:
 
 # Engines: interchangeable terminal workers
 
-One contract, eleven live profiles. The orchestrator writes a bounded task prompt, dispatches it to an engine, then **independently verifies, lands, and pushes** the result. Engines never self-certify.
+One contract, twelve live profiles. The orchestrator writes a bounded task prompt, dispatches it to an engine, then **independently verifies, lands, and pushes** the result. Engines never self-certify.
 
 ## Pick the job owner first
 
@@ -46,6 +47,18 @@ The first worker that is ready and not expired leads; the rest are backups in or
 
 **What happens on its own.** A worker that stalls or loses its connection sits out 30 minutes ("cooling") and the next worker takes the job; a failed task (tests failed) is not handed over and does not bench anyone. Every run is recorded; `atris engine roster --runs` lists them and the roster shows each worker's recent record. When the record says the order is wrong, the roster prints one suggestion with the exact command. It never edits the file: run it only when the owner says so.
 
+**Team members: model and runs on.** A line under `## team` gives one member its own model, and an `on:` part says where it works:
+
+```
+## team
+- cosmo: claude code, model: opus 5.5
+- vannevar: muse, model: muse wonder
+- walsh: claude code, model: opus 5.5, on: atris computer
+- amara: on: grok bot
+```
+
+No `on:` means this machine. `on: atris computer` is the computer Atris hosts; any other name (`grok bot`, `claude duet`, `dots`) is a bot on its own machine. A member that works elsewhere never runs here: its missions pause with "runs on <place>", and the roster shows a RUNS ON column. Set it with `atris engine roster set --member <name> [<tool> <model>] [--on "<place>"]`; moving a member keeps its engine, and swapping its engine keeps its place. The machine that is that place says so with `ATRIS_RUNS_AS="grok bot"` or one line in `~/.atris/RUNS_AS`; there the member runs, and everywhere else it is skipped.
+
 **Heavy models.** Astra and Fable should judge, not explore. Give their line `prep: search`: the search lead writes a brief of at most 300 lines first, and if prep fails the worker runs as usual.
 
 **Team members.** Navigators, researchers, and scouts do search; validators, reviewers, and judges do review; everyone else builds. A `## team` line overrides: `- researcher: search` or `- judge: claude code, model: opus 5.5`. `member run`, owned missions, and autopilot phases use the member's pick; `--engine` still wins. Parked members are skipped; `atris team park <name>` and `atris team unpark <name>` toggle it.
@@ -99,6 +112,7 @@ Smoke: `reply with the word OK`, run from `$HOME`, 120s cap, one at a time on a
 | Devin (build) | `devin -p --permission-mode dangerous --model swe-2-max --prompt-file <brief>` (run from an isolated worktree) | `swe-2-max` (Free tag in `devin models list`, 2026-09-23) | 2026-09-23 | 14.0 | In `-p` mode the default permission mode rejects shell commands too, so even a read-only audit dies after one step (2026-09-23). Keep the brief outside the worktree. Long runs (5+ min) can print nothing even on success: judge by the worktree diff. `devin cloud` outlives this machine. |
 | Devin (search) | `devin -p --permission-mode dangerous --model swe-1.7-lightning -- "<prompt>"` | `swe-1.7-lightning` (paid, no Free tag on 2026-09-23) | 2026-09-23 | 13.9 | |
 | Grok | `grok --always-approve --model grok-4.7 -p "<prompt>"` (run from the target repo) | `grok-4.7` | 2026-09-23 | 11.7 | Unpinned default is now `grok-4.7-build-fast`; `grok models` lists the menu. Uses grok.com login. `--best-of-n <N>` for tricky bounded builds. |
+| Muse | `muse exec --sandbox-network enabled --trust-workspace --model muse-wonder-1.0 "<prompt>"` (run from the target repo) | `muse-wonder-1.0` | 2026-11-11 | - | Meta's Muse Code. Runs only Muse models (`muse wonder`, `muse spark`). Its sandbox proxies the network by default, which blocks atris calls; `enabled` keeps the sandbox and approval judge on. Read-only asks add `--disable-write`. |
 | Antigravity (agy) | `agy --mode accept-edits --add-dir "$PWD" --model gemini-3.8-flash-high --output-format json -p "<prompt>"` (run from the target repo) | `gemini-3.8-flash-high` | 2026-09-23 | 15.9 | **`--add-dir` is mandatory for writes**: without it agy edits `~/.gemini/antigravity-cli/scratch/` and the project never changes (2026-08-28). `--mode plan --sandbox` for read-only review. Also answers to "gemini". |
 | opencode | `opencode run -m opencode/muse-spark-1.3-contributor-free "<prompt>"` (read-only: add `--agent plan`) | `opencode/muse-spark-1.3-contributor-free` | 2026-09-23 | 41.1 | Build work needs `--auto` (isolated worktree only). `opencode models` lists the live menu. |
 
@@ -123,6 +137,7 @@ Headless dispatch permissions (verified 2026-08-11): `codex exec`, `grok`, and `
 | Devin | `--model <id>` | `swe-2-max`, `swe-2-high`, `swe-2-medium` (Free); `claude-opus-5-5-high`, `gpt-6-sol` (paid) |
 | Cursor | `--model <id>` | `composer-2.5`, `grok-4.7-xhigh`, `claude-opus-5-thinking-high`; `--list-models` |
 | Grok | `--model <id>` | `grok-4.7`, `grok-4.7-build-fast` (default), `grok-4.6`, `grok-4.5`; `grok models` |
+| Muse | `--model <id>` | `muse-wonder-1.0`, `muse-spark-1.3`; `muse model-profile show <id>` |
 | Codex | `-m <id>` | `gpt-6-sol` is the `~/.codex/config.toml` default |
 
 Pins expire 30 days after their verified date. Re-verify on a new model: run the CLI's model list, smoke one prompt, update the row.

package/ax

@@ -3134,8 +3134,12 @@ function buildPayload(message, options = {}) {
     // /terminal endpoint. The workspace_path is a label, not a local path.
     payload.workspace_path = `/workspace/${options.business.slug}`;
     payload.local_executor = true;
-  } else if (local) {
-    payload.workspace_path = options.cwd || process.cwd();
+  } else {
+    // Say this is the person's own terminal chat, so the backend gives it their
+    // Atris memory (what they told Atris, and remember/save). Business turns
+    // keep the shape they have today and name no surface.
+    payload.surface = 'cli';
+    if (local) payload.workspace_path = options.cwd || process.cwd();
   }
   if (options.connectionContext) {
     payload.connection_context = options.connectionContext;

package/bin/atris.js

@@ -774,6 +774,7 @@ function showHelpAll() {
   console.log('  switch     - Switch account globally (atris switch <name>)');
   console.log('  use        - Set account for this terminal only (atris use <name>)');
   console.log('  accounts   - Manage accounts (list, add, remove)');
+  console.log('  film       - See film projects and suggest edits (list, show, propose, status; --json)');
   console.log('  balance    - Show credit balance in dollars');
   console.log('  usage      - Show developer API usage');
   console.log('  api-key    - Create, list, rotate, or revoke a developer API key');
@@ -2531,6 +2532,10 @@ if (command === 'guide') {
   Promise.resolve().then(() => require('../commands/memory').memoryCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(String(err.message || err).replace(/\s+/g, ' ')); process.exit(1); });
+} else if (command === 'film') {
+  Promise.resolve().then(() => require('../commands/film').filmCommand(process.argv.slice(3)))
+    .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(String(err.message || err).replace(/\s+/g, ' ')); process.exit(1); });
 } else if (command === 'balance') {
   Promise.resolve().then(() => require('../commands/balance').balanceCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))

package/commands/ask.js

@@ -7,11 +7,27 @@
  */
 
 const readline = require('readline');
-const { getApiBaseUrl, httpRequest, apiRequestJson } = require('../utils/api');
+const api = require('../utils/api');
 const auth = require('../utils/auth');
 
+const { getApiBaseUrl, apiRequestJson } = api;
+
 const TIMEOUT_MS = 300000;
 
+// A request like "run date on my computer" can come back as a started job
+// instead of an answer. These keep the terminal open until the job is done.
+const JOB_FIRST_POLL_MS = 1500;
+const JOB_MAX_POLL_MS = 3000;
+const JOB_WAIT_CAP_MS = 5 * 60 * 1000;
+const JOB_POLL_TIMEOUT_MS = 20000;
+// Consecutive polls that may fail (network drop, 5xx) before we give up.
+const JOB_POLL_FAILURE_LIMIT = 4;
+// Consecutive 404s before we say the job is gone. One is tolerated in case
+// the first read lands before the saved job is visible.
+const JOB_NOT_FOUND_LIMIT = 2;
+const CHECK_COMMAND = 'atris chat --personal "how is it going"';
+const JOB_INTENTS = new Set(['mission_start', 'mission_answer', 'mission_approve', 'mission_correction']);
+
 function stripEvents(text) {
   // Drop inline [[EVENT]]{...} tool chatter; keep only the spoken reply.
   // Tool names are surfaced dimmed in the terminal (texts never see them).
@@ -52,13 +68,14 @@ function stripEvents(text) {
 }
 
 function startSpinner(label) {
-  if (!process.stdout.isTTY) return { stop: () => {} };
+  if (!process.stdout.isTTY) return { stop: () => {}, setLabel: () => {} };
   const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
   const started = Date.now();
   let i = 0;
+  let current = label;
   const timer = setInterval(() => {
     const secs = Math.floor((Date.now() - started) / 1000);
-    process.stdout.write(`\r${frames[i % frames.length]} ${label}${secs > 2 ? ` · ${secs}s` : ''}   `);
+    process.stdout.write(`\r\x1b[2K${frames[i % frames.length]} ${current}${secs > 2 ? ` · ${secs}s` : ''}`);
     i += 1;
   }, 90);
   return {
@@ -66,6 +83,7 @@ function startSpinner(label) {
       clearInterval(timer);
       process.stdout.write('\r\x1b[2K');
     },
+    setLabel: (next) => { if (next) current = String(next); },
   };
 }
 
@@ -83,7 +101,7 @@ async function typeOut(text) {
 }
 
 async function sendMessage(token, message) {
-  const res = await httpRequest(`${getApiBaseUrl()}/message/incoming`, {
+  const res = await api.httpRequest(`${getApiBaseUrl()}/message/incoming`, {
     method: 'POST',
     headers: {
       Authorization: `Bearer ${token}`,
@@ -100,7 +118,165 @@ async function sendMessage(token, message) {
   return JSON.parse(res.body.toString('utf8'));
 }
 
-async function askAtris(args) {
+// The job id when this reply started (or restarted) a job the person should
+// wait for. Replies that only report on a job (status, stop) carry no wait.
+function startedJobId(body) {
+  if (!body || typeof body !== 'object' || body.success === false) return null;
+  if (!JOB_INTENTS.has(body.intent)) return null;
+  const id = body.card && body.card.mission_id;
+  return typeof id === 'string' && id ? id : null;
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function fetchJob(token, jobId) {
+  const url = `${getApiBaseUrl()}/atris2/missions/${encodeURIComponent(jobId)}?details=true`;
+  let res;
+  try {
+    res = await api.httpRequest(url, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${token}` },
+      timeoutMs: JOB_POLL_TIMEOUT_MS,
+    });
+  } catch (err) {
+    return { transient: true, error: err && err.message ? err.message : String(err) };
+  }
+  const status = res && res.status;
+  if (status === 200) {
+    try {
+      return { job: JSON.parse(res.body.toString('utf8')) };
+    } catch (_) {
+      return { transient: true, error: 'unreadable reply' };
+    }
+  }
+  if (status === 404) return { notFound: true };
+  if (status === 401 || status === 403) return { signedOut: true };
+  return { transient: true, error: `HTTP ${status}` };
+}
+
+// What a polled job says right now: done (with its answer), needs the person,
+// stopped, failed, waiting for a computer, or still working.
+function readJob(job) {
+  const result = job && typeof job.result === 'object' && job.result ? job.result : {};
+  const proof = job && typeof job.proof === 'object' && job.proof ? job.proof : {};
+  const state = String((job && job.state) || '').toLowerCase();
+  const status = String((job && job.status) || '').toLowerCase();
+  const text = [result.response, result.summary, proof.summary, job && job.summary]
+    .map((value) => (typeof value === 'string' ? value.trim() : ''))
+    .find(Boolean) || '';
+  if (status === 'completed' || state === 'done') return { kind: 'done', text };
+  if (status === 'cancelled') return { kind: 'stopped' };
+  const detail = [result.message, result.error]
+    .map((value) => (typeof value === 'string' ? value.trim() : ''))
+    .find(Boolean) || '';
+  if (status === 'failed') {
+    // A hard-capped job that failed reads "stopped"; any other failure is a failure.
+    return state === 'stopped' ? { kind: 'stopped', detail } : { kind: 'failed', detail };
+  }
+  if (state === 'stopped') return { kind: 'stopped', detail };
+  if (state === 'your_turn') {
+    const needs = job.needs && typeof job.needs === 'object' ? job.needs : {};
+    const question = String(needs.question || job.next || '').trim();
+    const options = Array.isArray(needs.options) ? needs.options.map(String).filter(Boolean) : [];
+    return { kind: 'needs', question: question || 'The job is waiting on you.', options };
+  }
+  if (state === 'waiting_for_computer') return { kind: 'no_computer' };
+  return { kind: 'working', label: typeof job.working_on === 'string' ? job.working_on : '' };
+}
+
+// Poll a started job until it ends, asks a question, or the wait cap passes.
+// Never throws: every way this can go wrong comes back as an outcome.
+async function waitForJob(token, jobId, { spinner, sleep = defaultSleep, now = Date.now, capMs = JOB_WAIT_CAP_MS } = {}) {
+  const startedAt = now();
+  let attempt = 0;
+  let failures = 0;
+  let notFound = 0;
+  for (;;) {
+    // eslint-disable-next-line no-await-in-loop
+    const polled = await fetchJob(token, jobId);
+    if (polled.signedOut) return { kind: 'signed_out' };
+    if (polled.notFound) {
+      notFound += 1;
+      failures = 0;
+      if (notFound >= JOB_NOT_FOUND_LIMIT) return { kind: 'lost' };
+    } else if (polled.transient) {
+      failures += 1;
+      notFound = 0;
+      if (failures >= JOB_POLL_FAILURE_LIMIT) return { kind: 'disconnected' };
+    } else {
+      failures = 0;
+      notFound = 0;
+      const read = readJob(polled.job);
+      if (read.kind !== 'working') return read;
+      if (spinner && read.label) spinner.setLabel(read.label);
+    }
+    const remaining = capMs - (now() - startedAt);
+    if (remaining <= 0) return { kind: 'timeout' };
+    attempt += 1;
+    const delay = Math.min(JOB_FIRST_POLL_MS + (attempt - 1) * 500, JOB_MAX_POLL_MS, remaining);
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(delay);
+  }
+}
+
+// Plain words for each way a wait can end. `failed` ones are errors for a
+// script (exit code 1); the rest are answers or a request for the person.
+function describeOutcome(outcome, { interactive = false } = {}) {
+  switch (outcome.kind) {
+    case 'done':
+      return { text: stripEvents(outcome.text) || 'The job finished, but it did not leave a written answer.' };
+    case 'needs': {
+      const lines = [`The job needs your answer: ${outcome.question}`];
+      if (outcome.options.length) lines.push(`Choices: ${outcome.options.join(', ')}`);
+      lines.push(interactive
+        ? 'Type your answer below.'
+        : 'Answer with: atris chat --personal "<your answer>"');
+      return { text: lines.join('\n') };
+    }
+    case 'timeout':
+      return { text: `Still working after ${Math.round(JOB_WAIT_CAP_MS / 60000)} minutes, and it keeps running. Check on it with: ${CHECK_COMMAND}` };
+    case 'no_computer':
+      return { text: 'This job is waiting for a computer to run on. It starts once your computer is running.' };
+    case 'stopped':
+      return { text: `That job was stopped before it finished.${outcome.detail ? ` ${outcome.detail}` : ''}`, failed: true };
+    case 'failed':
+      return {
+        text: `The job did not finish${outcome.detail ? `: ${outcome.detail}` : '.'} Say it a little differently to start a fresh try.`,
+        failed: true,
+      };
+    case 'lost':
+      return { text: 'I lost track of that job, so I cannot tell you how it went. Ask again to start a new one.', failed: true };
+    case 'signed_out':
+      return { text: 'Your sign-in no longer works for this job. Run "atris login", then ask for an update.', failed: true };
+    case 'disconnected':
+    default:
+      return {
+        text: `Lost the connection while the job was running. It may still be working. Check with: ${CHECK_COMMAND}`,
+        failed: true,
+      };
+  }
+}
+
+// One person's message, start to finish: send it, and when the reply is a
+// started job, wait for the job's real answer instead of stopping at "I'm starting now".
+async function askOnce(token, message, { spinner, interactive = false, wait = {} } = {}) {
+  const body = await sendMessage(token, message);
+  const jobId = startedJobId(body);
+  if (!jobId) return { text: stripEvents(body.response) || JSON.stringify(body) };
+  if (spinner) spinner.setLabel('working on it');
+  const outcome = await waitForJob(token, jobId, { spinner, ...wait });
+  const described = describeOutcome(outcome, { interactive });
+  // The same words always map to the same job, so asking again can return a finished one.
+  if (outcome.kind === 'done' && body.intent === 'mission_start'
+    && body.card && String(body.card.state || '').toLowerCase() === 'done') {
+    described.note = 'This is the answer from the last time you asked this. Reword it to run it again.';
+  }
+  return described;
+}
+
+async function askAtris(args, options = {}) {
   const ensured = await auth.ensureValidCredentials(apiRequestJson);
   if (ensured.error === 'not_logged_in' || !ensured.credentials?.token) {
     console.error('✗ Not logged in. Run "atris login" first.');
@@ -125,15 +301,23 @@ async function askAtris(args) {
 
   if (oneShot) {
     const spinner = startSpinner('thinking');
+    let answer;
     try {
-      const body = await sendMessage(token, oneShot);
-      spinner.stop();
-      await typeOut(stripEvents(body.response) || JSON.stringify(body));
+      answer = await askOnce(token, oneShot, { spinner, wait: options });
     } catch (err) {
       spinner.stop();
       console.error(`✗ ${err.message}`);
       process.exit(1);
+      return;
+    }
+    spinner.stop();
+    if (answer.note) console.error(answer.note);
+    if (answer.failed) {
+      console.error(`✗ ${answer.text}`);
+      process.exit(1);
+      return;
     }
+    await typeOut(answer.text);
     return;
   }
 
@@ -150,11 +334,16 @@ async function askAtris(args) {
     busy = true;
     const spinner = startSpinner('thinking');
     try {
-      const body = await sendMessage(token, message);
+      const answer = await askOnce(token, message, { spinner, interactive: true, wait: options });
       spinner.stop();
-      process.stdout.write('\natris › ');
-      await typeOut(stripEvents(body.response) || JSON.stringify(body));
-      process.stdout.write('\n');
+      if (answer.note) console.error(answer.note);
+      if (answer.failed) {
+        console.error(`✗ ${answer.text}\n`);
+      } else {
+        process.stdout.write('\natris › ');
+        await typeOut(answer.text);
+        process.stdout.write('\n');
+      }
     } catch (err) {
       spinner.stop();
       console.error(`✗ ${err.message}\n`);
@@ -172,4 +361,4 @@ async function askAtris(args) {
   });
 }
 
-module.exports = { askAtris };
+module.exports = { askAtris, readJob, startedJobId, waitForJob, describeOutcome };

package/commands/engine.js

@@ -1374,12 +1374,22 @@ function teamActivityTag(activity) {
 function renderTeamRoster(rows, { width } = {}) {
   if (!rows.length) return '';
   const showActivity = rows.some((row) => row.activity !== undefined);
-  const columns = [{ header: 'MEMBER' }, { header: 'JOB' }, { header: 'ENGINE · MODEL' }, { header: 'SOURCE' }];
+  // RUNS ON shows once any member works on another machine; an all-local
+  // team reads exactly as before.
+  const showPlace = rows.some((row) => row.runs_here === false);
+  const columns = [{ header: 'MEMBER' }, { header: 'JOB' }, { header: 'ENGINE · MODEL' }];
+  if (showPlace) columns.push({ header: 'RUNS ON' });
+  columns.push({ header: 'SOURCE' });
   if (showActivity) columns.push({ header: 'LAST 7 DAYS', clip: true, min: 11 });
   const cells = rows.map((row) => {
-    const engine = row.engine ? workerCellText(engineRunsView(row.engine, { model: row.model || '', effort: row.effort || '' })) : 'no ready engine';
+    const elsewhere = row.runs_here === false;
+    const engine = row.engine
+      ? workerCellText(engineRunsView(row.engine, { model: row.model || '', effort: row.effort || '' }))
+      : elsewhere ? 'its own model' : 'no ready engine';
     const stale = row.stale_model && row.newer_model ? ` (newer ${modelLabel(row.newer_model)} out)` : '';
-    const cell = [row.member, row.job || '-', `${engine}${stale}`, row.source === 'file' ? (row.file || 'roster file') : 'automatic'];
+    const cell = [row.member, row.job || '-', `${engine}${stale}`];
+    if (showPlace) cell.push(row.runs_on_label || row.runs_on || '-');
+    cell.push(row.source === 'file' ? (row.file || 'roster file') : 'automatic');
     if (showActivity) cell.push(teamActivityTag(row.activity));
     return cell;
   });
@@ -1520,7 +1530,7 @@ function runRosterRunsCommand(job, json, root, now) {
   return 0;
 }
 
-const ROSTER_SET_USAGE = 'usage: atris engine roster set <job> <tool> <model>, or atris engine roster set --member <name> <tool> <model>. the tools and models come from atris engine roster --available';
+const ROSTER_SET_USAGE = 'usage: atris engine roster set <job> <tool> <model>, or atris engine roster set --member <name> [<tool> <model>] [--on "<place>"]. --on is where the member works: "atris computer", "local", or a bot on another machine like "grok bot". the tools and models come from atris engine roster --available';
 
 // The words after set: the job (one quoted argument, or every word before
 // the first one that names a tool), the tool (one word, or two like "claude
@@ -1569,19 +1579,51 @@ function runRosterSetCommand(args, root) {
       return 2;
     }
   }
+  let place = null;
+  const onAt = words.indexOf('--on');
+  if (onAt !== -1) {
+    place = words[onAt + 1] || '';
+    words.splice(onAt, 2);
+    if (!member || !place || place.startsWith('--')) {
+      console.error(ROSTER_SET_USAGE);
+      return 2;
+    }
+  }
   if (words.some((word) => String(word).startsWith('--'))) {
     console.error(ROSTER_SET_USAGE);
     return 2;
   }
-  const parts = splitSetWords(words, !member);
+  const parts = place !== null && !words.length ? {} : splitSetWords(words, !member);
   if (!parts || (!member && !parts.job)) {
     console.error(ROSTER_SET_USAGE);
     return 2;
   }
   try {
-    const out = member
+    let lineScope = 'project';
+    if (place !== null) {
+      // a bad place or an unknown member is refused before anything is written
+      const { readMemberCard, teamLineFor } = require('../lib/member-engine');
+      const reg = require('../lib/engine-registry');
+      reg.setTeamPlaceCheck(place);
+      // member names are lowercase on disk, the same way swapMember reads them
+      member = member.trim().toLowerCase();
+      const line = teamLineFor(reg.readRosterState(root), member);
+      if (!line && !readMemberCard(root, member).found) throw new Error(`there is no team member named ${member}`);
+      if (line && line.scope) lineScope = line.scope;
+    }
+    let out = member && parts.tool
       ? swapMember(root, member, parts.tool, parts.model)
-      : swapJob(root, parts.job, parts.tool, parts.model);
+      : member ? null : swapJob(root, parts.job, parts.tool, parts.model);
+    if (place !== null) {
+      const { setTeamPlace } = require('../lib/engine-registry');
+      // the place goes on the line that decides for this member
+      const scope = out && out.scope ? out.scope : lineScope;
+      const placed = setTeamPlace(member, place, scope === 'session' ? { session: true } : scope === 'machine' ? { everywhere: true } : {}, root);
+      const { runsOnText } = require('../lib/runs-on');
+      const where = runsOnText(placed.place, placed.place.engine || '');
+      out = { ...(out || { member }), runs_on: placed.place.id, runs_on_label: placed.place.label, runs_here: placed.place.here, value: placed.value,
+        line: `${out && out.changed ? `${out.line} ` : ''}${member} now works on ${where}.` };
+    }
     console.log(json ? JSON.stringify(out, null, 2) : out.line);
     return 0;
   } catch (err) {

package/commands/film.js

@@ -0,0 +1,191 @@
+'use strict';
+
+// atris film: see film projects and suggest edits. Agents only suggest; the
+// person approves in their film editor. Backend: /api/film-studio/*.
+
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { NOT_LOGGED_IN, wantsHelp, wantsJson, tokenFrom, oneLine } = require('../lib/developer-api');
+
+const BASE = '/film-studio';
+const POLL_MS = 2000;
+const MAX_POLLS = 30; // 60 seconds
+const DONE_STATES = new Set(['done', 'refused', 'expired']);
+
+function showFilmHelp(log = console.log) {
+  log('usage: atris film [list] [--json]');
+  log('       atris film show <slug> [--json]');
+  log('       atris film propose <slug> \'<op json>\' --why "<one line>" [--wait] [--json]');
+  log('       atris film status <id> [--json]');
+  log('see film projects and suggest edits. Times are frames (30 a second).');
+  log('proposals change nothing until the person approves them in their editor.');
+}
+
+function parseArgs(args) {
+  const out = { positional: [], why: '', wait: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const a = String(args[i]);
+    if (a === '--json') continue;
+    if (a === '--wait') out.wait = true;
+    else if (a === '--why') { out.why = String(args[i + 1] == null ? '' : args[i + 1]); i += 1; }
+    else if (a.startsWith('--why=')) out.why = a.slice(6);
+    else out.positional.push(a);
+  }
+  return out;
+}
+
+const secs = (f, fps) => (Number(f) / (fps || 30)).toFixed(2);
+
+function describeEdit(e) {
+  if (!e || typeof e !== 'object') return String(e);
+  const who = e.by || 'someone';
+  const text = e.summary || (e.op ? JSON.stringify(e.op) : 'an edit');
+  const label = e.n != null ? `#${e.n}` : (e.id ? `#${e.id}` : '-');
+  const state = e.status ? ` (${e.status})` : '';
+  const why = e.why ? ` Why: ${oneLine(e.why)}` : '';
+  return `${label} ${who}${state}: ${oneLine(text)}${why}`;
+}
+
+function showLines(d) {
+  const tl = d.timeline && typeof d.timeline === 'object' ? d.timeline : {};
+  const fps = Number(tl.fps) || 30;
+  const bubbles = Array.isArray(tl.bubbles) ? tl.bubbles : [];
+  const lines = [`${d.title || d.slug} (${d.slug})  version ${d.version == null ? '?' : d.version}`];
+  lines.push(`Editor Mac: ${d.mac_online ? 'online' : 'off'}${d.render_status ? `, render: ${d.render_status}` : ''}`);
+  lines.push(`${tl.width || '?'}x${tl.height || '?'} at ${fps} fps, ${tl.duration_f || 0} frames (${secs(tl.duration_f || 0, fps)} s), ${bubbles.length} bubbles`);
+  const order = (Array.isArray(tl.tracks) ? tl.tracks.map((t) => t.id) : []);
+  for (const b of bubbles) if (!order.includes(b.track)) order.push(b.track);
+  for (const track of order) {
+    const rows = bubbles.filter((b) => b.track === track).sort((a, b) => a.start_f - b.start_f);
+    lines.push('', track);
+    if (!rows.length) lines.push('  (empty)');
+    for (const b of rows) {
+      const what = b.label || (b.source && (b.source.file || b.source.kind)) || '';
+      lines.push(`  ${b.id}  frames ${b.start_f}-${b.end_f}  ${secs(b.start_f, fps)}-${secs(b.end_f, fps)} s  ${what}${b.locked ? '  [locked]' : ''}`);
+    }
+  }
+  const notes = Array.isArray(tl.notes) ? tl.notes : [];
+  if (notes.length) {
+    lines.push('', 'notes');
+    for (const n of notes) lines.push(`  ${n.id}  frame ${n.t_f} (${secs(n.t_f, fps)} s)  ${oneLine(n.text)}`);
+  }
+  const edits = (Array.isArray(d.edits) ? d.edits : []).slice(-10);
+  lines.push('', 'last edits');
+  if (!edits.length) lines.push('  none yet');
+  for (const e of edits) lines.push(`  ${describeEdit(e)}`);
+  const pending = Array.isArray(d.pending) ? d.pending : [];
+  lines.push('', `pending proposals: ${pending.length}`);
+  for (const e of pending) lines.push(`  ${describeEdit(e)}`);
+  return lines;
+}
+
+function commandLines(c, id) {
+  const status = c.status || 'unknown';
+  if (status === 'done') return ['Done. Your suggestion reached the editor and is waiting for the person to approve it.'];
+  if (status === 'refused') return [`Refused: ${oneLine(c.error)}`];
+  if (status === 'expired') return ['Expired: the editor Mac did not pick it up in time. Try again when it is on.'];
+  return [`${status}. Check later: atris film status ${id}`];
+}
+
+async function filmCommand(args = [], deps = {}) {
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  if (wantsHelp(args)) { showFilmHelp(io.log); return 0; }
+  const json = wantsJson(args);
+  const request = deps.apiRequestJson || apiRequestJson;
+  const sleep = deps.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const fail = (message, extra = {}) => {
+    if (json) io.log(JSON.stringify({ ok: false, error: message, ...extra }));
+    else io.err(message);
+    return 1;
+  };
+  const ok = (payload, lines) => {
+    if (json) io.log(JSON.stringify({ ok: true, ...payload }));
+    else for (const l of lines) io.log(l);
+    return 0;
+  };
+  const token = tokenFrom((deps.loadCredentials || loadCredentials)());
+  if (!token) return fail(NOT_LOGGED_IN);
+  const call = async (path, options = {}) => {
+    try {
+      const res = await request(`${BASE}${path}`, { token, ...options });
+      return res || { ok: false, error: 'request failed' };
+    } catch (e) {
+      return { ok: false, error: oneLine(e && e.message) };
+    }
+  };
+
+  const { positional, why, wait } = parseArgs(args);
+  const sub = positional[0] || 'list';
+
+  if (sub === 'list') {
+    const res = await call('/projects');
+    if (!res.ok) return fail(oneLine(res.error), { status: res.status });
+    const d = res.data || {};
+    const projects = Array.isArray(d.projects) ? d.projects : [];
+    const lines = [`Editor Mac: ${d.mac_online ? 'online' : 'off'}`];
+    if (!projects.length) lines.push('No film projects yet.');
+    for (const p of projects) {
+      lines.push(`${p.slug}  ${p.title || ''}  version ${p.version == null ? '?' : p.version}  ${p.pending_count || 0} pending  updated ${p.updated_at || '?'}`);
+    }
+    return ok({ mac_online: Boolean(d.mac_online), projects }, lines);
+  }
+
+  if (sub === 'show') {
+    const slug = positional[1];
+    if (!slug) return fail('usage: atris film show <slug>');
+    const res = await call(`/projects/${encodeURIComponent(slug)}`);
+    if (!res.ok) return fail(oneLine(res.error), { status: res.status });
+    return ok({ project: res.data }, showLines({ slug, ...(res.data || {}) }));
+  }
+
+  if (sub === 'status') {
+    const id = positional[1];
+    if (!id) return fail('usage: atris film status <id>');
+    const res = await call(`/commands/${encodeURIComponent(id)}`);
+    if (!res.ok) return fail(oneLine(res.error), { status: res.status });
+    return ok({ command_id: id, ...(res.data || {}) }, commandLines(res.data || {}, id));
+  }
+
+  if (sub === 'propose') {
+    const [, slug, raw] = positional;
+    if (!slug || !raw) return fail('usage: atris film propose <slug> \'<op json>\' --why "<one line>" [--wait]');
+    if (!why.trim()) return fail('add --why "<one line>" so the person knows the reason for this edit');
+    let op;
+    try { op = JSON.parse(raw); } catch { return fail('the edit is not valid JSON. Example: \'{"op":"move","id":"<bubble id>","start_f":30}\''); }
+    if (!op || typeof op !== 'object' || Array.isArray(op) || typeof op.op !== 'string') {
+      return fail('the edit must be a JSON object with an "op" name, like {"op":"move","id":"<bubble id>","start_f":30}');
+    }
+    const res = await call(`/projects/${encodeURIComponent(slug)}/commands`, {
+      method: 'POST',
+      body: { kind: 'op', payload: { op, propose: true }, why: why.trim() },
+    });
+    if (!res.ok) return fail(oneLine(res.error), { status: res.status });
+    const id = res.data && res.data.command_id;
+    if (!id) return fail('the server did not return a command id');
+    if (!wait) {
+      return ok({ command_id: id, status: 'pending' }, [`Queued proposal ${id}. It changes nothing until the person approves it in their editor.`, `Check it: atris film status ${id}`]);
+    }
+    let last = { status: 'pending' };
+    for (let i = 0; i < MAX_POLLS; i += 1) {
+      await sleep(POLL_MS);
+      const poll = await call(`/commands/${encodeURIComponent(id)}`);
+      if (poll.ok && poll.data) {
+        last = poll.data;
+        if (DONE_STATES.has(last.status)) break;
+      }
+    }
+    const lines = DONE_STATES.has(last.status)
+      ? commandLines(last, id)
+      : [`Still ${last.status || 'pending'} after 60 s. The editor Mac may be off.`, `Check later: atris film status ${id}`];
+    const finished = DONE_STATES.has(last.status);
+    const payload = { command_id: id, ...last, status: last.status || 'pending' };
+    if (json) io.log(JSON.stringify({ ok: last.status === 'done', ...payload }));
+    else for (const l of lines) (last.status === 'done' || !finished ? io.log : io.err)(l);
+    if (last.status === 'done') return 0;
+    return finished ? 1 : 2;
+  }
+
+  return fail(`unknown film command "${sub}". Try: atris film --help`);
+}
+
+module.exports = { filmCommand };