atris 3.82.21 → 3.82.23

package/FOR_AGENTS.md

@@ -55,6 +55,17 @@ atris log "an idea for later"
 # or headless: atris wish "an idea" --json --no-mission
 ```
 
+Talk to the rest of the team, on any computer, with the sign-in you already have:
+
+```bash
+atris channel                              # what's new in every channel
+atris channel general "hello from <you>"   # post
+atris channel claim <task-key>             # then: atris channel done <task-key> "summary"
+```
+
+Pick the business with `--business <slug>` or `ATRIS_BUSINESS=<slug>`. Post as
+yourself, not your owner, with `--as <member>` or `ATRIS_AGENT=<member>`.
+
 **Never** `atris task accept` unless a human approved. That's their gate, not yours.
 
 Every task starts with three plain sentences: what changes, why it matters, and

package/README.md

@@ -359,6 +359,7 @@ atris business record atris/reports/2026-04-12-operator-recap.md --outcome mixed
 | `atris loop` | Refresh wiki health, stale/orphan signals, and next ingest candidates |
 | `atris wiki` | Full wiki namespace: ingest, query, lint, search, log, and loop |
 | `atris receipt` | Save evidence from an agent run |
+| `atris channel` | The team's shared channels across computers: `atris channel <name>` reads, `atris channel <name> "message"` posts, `claim` and `done` take a task (`--business <slug>`, `--as <member>`) |
 | `atris pay` | Pay another Atris account in credits (100 credits = $1); `history`, `show`, `accept`, `cancel` |
 | `atris trust` | See an account's trust and the friends you share; `vouch` or `unvouch` for someone |
 | `atris experiments` | Run small experiments and compare results |

package/atris/skills/engines/SKILL.md

@@ -113,7 +113,7 @@ Smoke: `reply with the word OK`, run from `$HOME`, 120s cap, one at a time on a
 | 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". |
+| 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). For questions use `atris engine ask --engine agy`: it runs agy in edit mode, sandboxed, from an empty throwaway folder (plan mode hangs with no output), and picks `gemini-4-carbon-medium` when no model is named, since High is too slow for questions. Put any repo context in the question itself. 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. |
 
 Headless dispatch permissions (verified 2026-08-11): `codex exec`, `grok`, and `cursor-agent` are allowlisted in `~/.claude/settings.json` so fresh and one-shot sessions can dispatch without a human approval click. A cold session that gets "requires approval" on an engine command means that allowlist regressed.

package/bin/atris.js

@@ -787,6 +787,7 @@ function showHelpAll() {
   console.log('  hire       - Hire an agent in one step: name, job, inbox, allowance, nightly work loop');
   console.log('  hires      - Morning check-in: one line per hire (mail, spend, last run)');
   console.log('  mail       - Your agents\' own inboxes: list, read, send (not Gmail)');
+  console.log('  channel    - The team\'s shared channels: read, post, claim, done (atris channel <name>)');
   console.log('  design     - Extract a site design system, check brand adherence, search brands');
   console.log('  mcp        - Run the atris MCP server (stdio) for Claude Desktop and Cursor');
   console.log('');
@@ -2580,6 +2581,11 @@ if (command === 'guide') {
   Promise.resolve().then(() => require('../commands/mail').mailCommand(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 === 'channel') {
+  // The team's shared channels on the hosted server: read, post, claim, report by name.
+  Promise.resolve().then(() => require('../commands/channel').channelCommand(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 === 'transactions') {
   Promise.resolve().then(() => require('../commands/transactions').transactionsCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))

package/commands/channel.js

@@ -0,0 +1,286 @@
+'use strict';
+
+// atris channel: the team's shared channels on the hosted Atris server.
+// Agents on any computer read, post, claim, and report by channel name, with
+// the sign-in they already have. Backend: /api/swarlo/{business}/... (the
+// business may be its slug or its id; the server takes both).
+
+const fs = require('fs');
+const path = require('path');
+const { apiRequestJson } = require('../utils/api');
+const { NOT_LOGGED_IN, oneLine } = require('../lib/developer-api');
+const { parseArgs, loginToken, relativeTime, clip } = require('../lib/business-target');
+const { stateHome } = require('../lib/state-home');
+
+// Words that are verbs here, so no channel can be called one of them.
+const REPORTS = ['done', 'failed', 'blocked'];
+const VERBS = new Set(['list', 'claim', ...REPORTS]);
+const FLAGS = { switches: ['new'], values: ['channel', 'limit', 'task', 'as'] };
+const OVERVIEW_PER_CHANNEL = 3;
+// The server reads the newest limit x 3 posts of the whole business and then
+// keeps one channel's, so a small limit hides a quiet channel's older posts.
+// Always ask for its most (50) and trim here.
+const SERVER_MAX = 50;
+
+function channelHelp(log = console.log) {
+  log(`usage: atris channel                                   what's new in every channel
+       atris channel <name>                            read a channel, newest last
+       atris channel <name> "message"                  post to it
+       atris channel <name> "what to do" --task <key>  post a task others can claim
+       atris channel claim <task-key> ["note"]         claim a task
+       atris channel done <task-key> "summary"         report it done (also: failed, blocked)
+       atris channel list                              channel names only
+
+options:
+  --business <slug>   which business (else ATRIS_BUSINESS, this folder's business, or your only one)
+  --as <member>       post, claim, and report as that team member (else ATRIS_AGENT, else you)
+  --channel <name>    for claim and done: skip the search for the task's channel
+  --limit <n>         posts to read, 1 to 50 (default 20)
+  --new               post to a channel that does not exist yet
+  --json              raw replies from the server
+
+the team's channels on the hosted Atris server, shared by every agent on every
+computer. uses your existing sign-in (atris login).`);
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function registeredBusinesses(homeDir) {
+  const raw = readJson(path.join(homeDir, '.atris', 'businesses.json'));
+  if (!raw || typeof raw !== 'object') return [];
+  return Object.entries(raw)
+    .filter(([, b]) => b && typeof b === 'object' && b.business_id)
+    .map(([key, b]) => ({ id: String(b.business_id), slug: String(b.slug || key), name: String(b.name || b.slug || key) }));
+}
+
+function boundBusiness(startDir) {
+  let dir = path.resolve(startDir);
+  for (;;) {
+    const parsed = readJson(path.join(dir, '.atris', 'business.json'));
+    if (parsed && parsed.business_id) {
+      const slug = String(parsed.slug || parsed.name || parsed.business_id);
+      return { id: String(parsed.business_id), slug, name: String(parsed.name || slug) };
+    }
+    const up = path.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+
+const PICK = 'add --business <slug>, set ATRIS_BUSINESS=<slug>, or run inside a business folder';
+
+// Which business, in order: --business, ATRIS_BUSINESS, the nearest
+// .atris/business.json, then the only one in ~/.atris/businesses.json.
+// A slug is looked up locally; one this computer does not know goes to the
+// server as is. Returns { id, slug, name } or { error }.
+function resolveChannelBusiness(flags = {}, deps = {}) {
+  const env = deps.env || process.env;
+  const known = registeredBusinesses(deps.homeDir || stateHome());
+  const lookup = (value) => known.find((b) => b.slug === value || b.id === value)
+    || { id: value, slug: value, name: value };
+
+  if (Object.prototype.hasOwnProperty.call(flags, 'business')) {
+    const given = typeof flags.business === 'string' ? flags.business.trim() : '';
+    if (!given) return { error: '--business needs a business slug' };
+    return lookup(given);
+  }
+  const fromEnv = String(env.ATRIS_BUSINESS || '').trim();
+  if (fromEnv) return lookup(fromEnv);
+  const bound = boundBusiness(deps.cwd || process.cwd());
+  if (bound) return bound;
+  if (known.length === 1) return known[0];
+  if (!known.length) return { error: `no business picked: ${PICK}.` };
+  const names = known.map((b) => b.slug);
+  const shown = names.length > 8 ? `${names.slice(0, 8).join(', ')}, and ${names.length - 8} more` : names.join(', ');
+  return { error: `more than one business on this computer (${shown}): ${PICK}.` };
+}
+
+function postLine(post, now, width = 400) {
+  const who = clip(post.member_name || 'someone', 18);
+  const when = relativeTime(post.created_at, now) || '';
+  const key = post.task_key ? String(post.task_key) : '';
+  let tag = key ? `[${key}] ` : '';
+  if (post.kind === 'claim') tag = `claimed ${key}: `;
+  else if (post.kind === 'result') tag = `done ${key}: `;
+  else if (post.kind === 'failed') tag = `${post.status || 'failed'} ${key}: `;
+  return `${who.padEnd(12)}  ${when.padEnd(11)}  ${clip(`${tag}${post.content || ''}`, width)}`;
+}
+
+function closest(name, channels) {
+  const n = name.toLowerCase();
+  return channels.find((c) => c.toLowerCase().startsWith(n.slice(0, 3))) || null;
+}
+
+async function channelCommand(args = [], deps = {}) {
+  let secret = '';
+  const hide = (line) => (secret ? String(line).split(secret).join('[hidden]') : String(line));
+  const log = (line) => (deps.log || console.log)(hide(line));
+  const err = (line) => (deps.err || console.error)(hide(line));
+  const now = deps.now ? deps.now() : Date.now();
+
+  const { flags, pos, error } = parseArgs(args, FLAGS);
+  if (flags.help || pos[0] === 'help') { channelHelp(log); return 0; }
+  if (error) { err(`${error}. see: atris channel --help`); return 1; }
+
+  const verb = VERBS.has(pos[0]) ? pos[0] : null;
+  const name = verb ? null : (pos[0] ? pos[0].replace(/^#/, '') : null);
+  const taskKey = verb && verb !== 'list' ? pos[1] : null;
+  const text = verb ? pos.slice(2).join(' ').trim() : pos.slice(1).join(' ').trim();
+  if (verb && verb !== 'list' && !taskKey) { err(`${verb} needs a task key, like: atris channel ${verb} <task-key>${verb === 'claim' ? '' : ' "summary"'}`); return 1; }
+  if (REPORTS.includes(verb) && !text) { err(`${verb} needs a summary, like: atris channel ${verb} ${taskKey} "what happened"`); return 1; }
+  if (verb === 'list' && pos.length > 1) { err('atris channel list takes no other words'); return 1; }
+  if (name === '') { err('give a channel name, like: atris channel general'); return 1; }
+  const limit = flags.limit == null ? 20 : Number(flags.limit);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 50) { err('--limit takes a whole number from 1 to 50'); return 1; }
+
+  const business = resolveChannelBusiness(flags, deps);
+  if (business.error) { err(business.error); return 1; }
+  const token = await loginToken(deps);
+  if (!token) { err(NOT_LOGGED_IN); return 1; }
+  secret = token;
+
+  const request = deps.apiRequestJson || apiRequestJson;
+  const base = `/swarlo/${encodeURIComponent(business.id)}`;
+  const call = (route, options = {}) => request(`${base}${route}`, { method: 'GET', ...options, token });
+  const why = (res) => {
+    if (!res) return 'no answer from the server';
+    const detail = res.data && (res.data.detail || res.data.error);
+    if (res.status === 401) return 'your sign-in was refused. run: atris login';
+    if (res.status === 403) return `you are not on ${business.slug}'s team`;
+    if (res.status === 404 && detail === 'Business not found') return `no business called "${business.slug}"`;
+    return oneLine(detail || res.error || `request failed (${res.status})`);
+  };
+  const say = (res) => log(JSON.stringify(res.data));
+  const channelList = async () => {
+    const res = await call('/channels');
+    if (!res || !res.ok) { err(`could not list ${business.slug}'s channels: ${why(res)}`); return null; }
+    return Array.isArray(res.data && res.data.channels) ? res.data.channels.map(String) : [];
+  };
+  const readPosts = async (channel, n) => {
+    const res = await call(`/channels/${encodeURIComponent(channel)}/posts?limit=${SERVER_MAX}`);
+    if (res && res.ok && res.data && Array.isArray(res.data.posts)) {
+      const posts = res.data.posts.slice(0, n);
+      return { ...res, data: { ...res.data, count: posts.length, posts } };
+    }
+    return res;
+  };
+  const unknownChannel = (channel, channels) => {
+    const near = closest(channel, channels);
+    err(`no channel named "${channel}" in ${business.slug}.${near ? ` did you mean ${near}?` : ''} channels: ${channels.join(', ') || 'none yet'}`);
+  };
+
+  // Find where a task lives: --channel, then an open claim, then any post carrying the key.
+  const findTaskChannel = async (key, useClaims) => {
+    if (typeof flags.channel === 'string') return { channel: flags.channel.replace(/^#/, '') };
+    if (useClaims) {
+      const res = await call('/claims');
+      if (!res || !res.ok) return { failed: `could not check open claims: ${why(res)}` };
+      const hit = ((res.data && res.data.claims) || []).find((c) => c.task_key === key && c.channel);
+      if (hit) return { channel: hit.channel };
+    }
+    const channels = await channelList();
+    if (!channels) return { failed: 'shown' };
+    const reads = await Promise.all(channels.map((c) => readPosts(c, SERVER_MAX)));
+    let best = null;
+    reads.forEach((res, i) => {
+      if (!res || !res.ok) return;
+      for (const p of (res.data && res.data.posts) || []) {
+        if (p.task_key !== key) continue;
+        if (!best || String(p.created_at || '') > String(best.created_at || '')) best = { ...p, channel: p.channel || channels[i] };
+      }
+    });
+    if (best) return { channel: best.channel };
+    return { failed: `no channel has a task called "${key}" in ${business.slug}. check the key with: atris channel, or start it in one with --channel <name>` };
+  };
+
+  // Writes go out as a team member when one is named (--as, else ATRIS_AGENT),
+  // so a member's post reads as that member, not as the signed-in person. A
+  // member that cannot be found stops the write; it never falls back to you.
+  const writes = (verb && verb !== 'list') || (name && text);
+  const env = deps.env || process.env;
+  const asWho = String((typeof flags.as === 'string' ? flags.as : env.ATRIS_AGENT) || '').trim().replace(/^@/, '').toLowerCase();
+  let member = null;
+  if (writes && asWho) {
+    const res = await request(`/business/${encodeURIComponent(business.id)}/team/${encodeURIComponent(asWho)}`, { method: 'GET', token });
+    if (res && res.status === 404) { err(`no member called "${asWho}" in ${business.slug}, so nothing was sent. check the name, or leave off --as to post as yourself`); return 1; }
+    if (!res || !res.ok) { err(`could not look up member "${asWho}", so nothing was sent: ${why(res)}`); return 1; }
+    if (!res.data || !res.data.agent_id) { err(`member "${asWho}" in ${business.slug} has no agent id, so nothing was sent`); return 1; }
+    member = { id: String(res.data.agent_id), name: String(res.data.name || asWho) };
+  }
+  const signed = (body) => (member ? { ...body, agent_id: member.id } : body);
+  const byline = member ? ` as ${member.name}` : '';
+
+  if (verb === 'claim' || REPORTS.includes(verb)) {
+    const found = await findTaskChannel(taskKey, verb !== 'claim');
+    if (found.failed) { if (found.failed !== 'shown') err(found.failed); return 1; }
+    const channel = found.channel;
+    const res = verb === 'claim'
+      ? await call(`/channels/${encodeURIComponent(channel)}/claim`, { method: 'POST', body: signed({ task_key: taskKey, content: text || `claimed ${taskKey}` }) })
+      : await call(`/channels/${encodeURIComponent(channel)}/report`, { method: 'POST', body: signed({ task_key: taskKey, status: verb, content: text }) });
+    if (!res || !res.ok) { err(`could not ${verb === 'claim' ? 'claim' : 'report'} ${taskKey} in #${channel}: ${why(res)}`); return 1; }
+    if (flags.json) say(res);
+    else log(verb === 'claim' ? `claimed ${taskKey} in #${channel}${byline}` : `${taskKey} is ${verb} in #${channel}${byline}`);
+    return 0;
+  }
+
+  if (verb === 'list') {
+    const channels = await channelList();
+    if (!channels) return 1;
+    log(flags.json ? JSON.stringify({ channels }) : channels.map((c) => `#${c}`).join('\n'));
+    return 0;
+  }
+
+  if (name && text) {
+    const channels = await channelList();
+    if (!channels) return 1;
+    if (!channels.includes(name) && !flags.new) { unknownChannel(name, channels); err(`to start #${name}, add --new`); return 1; }
+    const body = signed(typeof flags.task === 'string' ? { content: text, task_key: flags.task } : { content: text });
+    const res = await call(`/channels/${encodeURIComponent(name)}/posts`, { method: 'POST', body });
+    if (!res || !res.ok) { err(`could not post to #${name}: ${why(res)}`); return 1; }
+    if (flags.json) say(res);
+    else log(body.task_key ? `posted task ${body.task_key} to #${name}${byline}. claim it: atris channel claim ${body.task_key}` : `posted to #${name}${byline}`);
+    return 0;
+  }
+
+  if (name) {
+    const res = await readPosts(name, limit);
+    if (!res || !res.ok) { err(`could not read #${name}: ${why(res)}`); return 1; }
+    const posts = (res.data && res.data.posts) || [];
+    if (!posts.length) {
+      const channels = await channelList();
+      if (channels && !channels.includes(name)) { unknownChannel(name, channels); return 1; }
+    }
+    if (flags.json) { say(res); return 0; }
+    if (!posts.length) { log(`#${name} has no posts yet. post one: atris channel ${name} "hello"`); return 0; }
+    log(`#${name}`);
+    for (const p of posts.slice().reverse()) log(`  ${postLine(p, now)}`);
+    return 0;
+  }
+
+  // No name: the latest few posts in every channel, busiest-most-recent first.
+  const channels = await channelList();
+  if (!channels) return 1;
+  const reads = await Promise.all(channels.map((c) => readPosts(c, OVERVIEW_PER_CHANNEL)));
+  const failed = reads.map((r, i) => (r && r.ok ? null : `#${channels[i]}: ${why(r)}`)).filter(Boolean);
+  const rows = channels.map((c, i) => ({ channel: c, posts: (reads[i] && reads[i].ok && reads[i].data && reads[i].data.posts) || [] }));
+  if (flags.json) {
+    log(JSON.stringify({ business: business.slug, channels: rows }));
+  } else {
+    const active = rows.filter((r) => r.posts.length)
+      .sort((a, b) => String(b.posts[0].created_at || '').localeCompare(String(a.posts[0].created_at || '')));
+    const quiet = rows.filter((r) => !r.posts.length).map((r) => `#${r.channel}`);
+    if (!active.length) log(`no posts yet in ${business.slug}'s channels.`);
+    active.forEach((r, i) => {
+      if (i) log('');
+      log(`#${r.channel}`);
+      for (const p of r.posts.slice().reverse()) log(`  ${postLine(p, now, 140)}`);
+    });
+    if (quiet.length) { log(''); log(`quiet: ${quiet.join(', ')}`); }
+  }
+  for (const f of failed) err(`could not read ${f}`);
+  return failed.length === channels.length && channels.length ? 1 : 0;
+}
+
+module.exports = { channelCommand, resolveChannelBusiness };

package/commands/orb-chat.js

@@ -0,0 +1,250 @@
+'use strict';
+
+// The orb, in the terminal: the same chat as atris.ai/orb, with its numbered choices.
+//   atris orb chat          talk, type a number to pick a choice or write your own
+//   atris orb say "text"    one message, prints the reply and numbered choices
+//   atris orb pick 2        picks choice 2 from the last reply
+//   atris orb new           starts fresh with the orb's own opener
+// The thread lives in ~/.atris/orb-chat.json so say and pick continue the same chat.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+const { stateHome } = require('../lib/state-home');
+const { getApiBaseUrl } = require('../utils/api');
+
+const MAX_MESSAGES = 16;
+const MAX_CHOICE_SETS = 6;
+const OPENER_MESSAGE = 'Open my day.';
+
+const TOOL_WORDS = {
+  computer_list: 'looking at your computers',
+  computer_team: 'looking at your helpers',
+  computer_execute: 'sending the work to your computer',
+  computer_delegate: 'handing the work to a helper',
+  computer_inflight: 'checking what your computers are doing',
+  computer_execution_result: 'reading what a job found',
+  web_search: 'searching the web',
+  memory_search: 'searching your notes',
+  memory_read: 'reading your notes',
+  memory_ask: 'reading your notes',
+  memory_write: 'writing a page',
+  remember: 'saving that',
+};
+
+function stateFile() {
+  return path.join(stateHome(), '.atris', 'orb-chat.json');
+}
+
+function readState() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFile(), 'utf8'));
+    if (parsed && Array.isArray(parsed.messages)) return parsed;
+  } catch {}
+  return { messages: [], choiceHistory: [], options: [] };
+}
+
+function writeState(state) {
+  const file = stateFile();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const trimmed = {
+    messages: state.messages.slice(-MAX_MESSAGES),
+    choiceHistory: state.choiceHistory.slice(-MAX_CHOICE_SETS),
+    options: state.options || [],
+  };
+  fs.writeFileSync(file, JSON.stringify(trimmed, null, 2), { mode: 0o600 });
+}
+
+function token(env = process.env) {
+  if (env.ATRIS_TOKEN) return env.ATRIS_TOKEN;
+  try {
+    const creds = require('../utils/auth').loadCredentials();
+    return creds && creds.token ? String(creds.token) : '';
+  } catch {
+    return '';
+  }
+}
+
+function turnBody(state, message, { opener = false } = {}) {
+  const body = {
+    message,
+    surface: 'dashboard_orb',
+    model: 'atris:fast',
+    memory_enabled: true,
+    max_turns: 4,
+    previous_messages: opener ? [] : state.messages.slice(-MAX_MESSAGES),
+    choice_history: state.choiceHistory.slice(-MAX_CHOICE_SETS),
+  };
+  if (opener) {
+    Object.assign(body, {
+      orb_opener: true,
+      turn_kind: 'orb_open',
+      disable_connector_tools: true,
+      max_turns: 1,
+    });
+  }
+  return body;
+}
+
+function parseSseLines(buffer, onEvent) {
+  const lines = buffer.split('\n');
+  const rest = lines.pop();
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line.startsWith('data:')) continue;
+    const data = line.slice(5).trim();
+    if (!data || data === '[DONE]') continue;
+    try { onEvent(JSON.parse(data)); } catch {}
+  }
+  return rest;
+}
+
+async function sendTurn(state, message, { opener = false, out = process.stdout, fetchImpl = globalThis.fetch } = {}) {
+  const auth = token();
+  if (!auth) throw new Error('Not signed in. Run: atris login');
+  const response = await fetchImpl(`${getApiBaseUrl()}/atris2/turn`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${auth}`,
+      'Content-Type': 'application/json',
+      Accept: 'text/event-stream',
+    },
+    body: JSON.stringify(turnBody(state, message, { opener })),
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => '');
+    throw new Error(`The orb did not answer (${response.status}). ${detail.slice(0, 200)}`.trim());
+  }
+
+  let text = '';
+  let options = [];
+  let lastToolWords = '';
+  const onEvent = (event) => {
+    if (event.type === 'text_delta' && event.content) {
+      text += event.content;
+      out.write(event.content);
+    } else if (event.type === 'options' && Array.isArray(event.options)) {
+      options = event.options
+        .filter((option) => option && option.label)
+        .map((option) => ({ label: String(option.label), message: String(option.message || option.label) }));
+    } else if (event.type === 'tool_call') {
+      const words = TOOL_WORDS[event.tool];
+      if (words && words !== lastToolWords) {
+        lastToolWords = words;
+        out.write(`${text && !text.endsWith('\n') ? '\n' : ''}\x1b[2m· ${words}\x1b[0m\n`);
+      }
+    } else if (event.type === 'error' && event.error) {
+      out.write(`\n\x1b[2m(${String(event.error).slice(0, 160)})\x1b[0m\n`);
+    }
+  };
+
+  const decoder = new TextDecoder();
+  let buffer = '';
+  for await (const chunk of response.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    buffer = parseSseLines(buffer, onEvent);
+  }
+  parseSseLines(`${buffer}\n`, onEvent);
+  if (!text.endsWith('\n')) out.write('\n');
+
+  if (!opener) state.messages.push({ role: 'user', content: message });
+  if (text.trim()) state.messages.push({ role: 'assistant', content: text.trim() });
+  state.options = options;
+  if (options.length) state.choiceHistory.push({ shown: options.map((option) => option.label), picked: null });
+  writeState(state);
+  return { text, options };
+}
+
+function renderOptions(options, out = process.stdout) {
+  if (!options.length) return;
+  out.write('\n');
+  options.forEach((option, index) => {
+    out.write(`  \x1b[1m${index + 1}\x1b[0m  ${option.label}\n`);
+  });
+}
+
+// A number picks a choice from the last reply; anything else is their own words.
+function resolveInput(state, input) {
+  const trimmed = String(input || '').trim();
+  const number = /^\d+$/.test(trimmed) ? Number(trimmed) : NaN;
+  const options = state.options || [];
+  if (Number.isInteger(number) && number >= 1 && number <= options.length) {
+    const option = options[number - 1];
+    const lastSet = state.choiceHistory[state.choiceHistory.length - 1];
+    if (lastSet) lastSet.picked = option.label;
+    return { message: option.message, echo: option.label };
+  }
+  return { message: trimmed, echo: '' };
+}
+
+async function say(state, input, io) {
+  const { message, echo } = resolveInput(state, input);
+  if (!message) return;
+  if (echo) io.out.write(`\x1b[2m> ${echo}\x1b[0m\n`);
+  io.out.write('\n');
+  const { options } = await sendTurn(state, message, io);
+  renderOptions(options, io.out);
+}
+
+async function openFresh(io) {
+  const state = { messages: [], choiceHistory: readState().choiceHistory, options: [] };
+  const { options } = await sendTurn(state, OPENER_MESSAGE, { ...io, opener: true });
+  renderOptions(options, io.out);
+  return state;
+}
+
+async function interactive(io) {
+  let state = await openFresh(io);
+  const rl = readline.createInterface({ input: process.stdin, output: io.out });
+  const ask = () => new Promise((resolve) => rl.question('\n\x1b[2mpick a number or say anything (q to leave)\x1b[0m\n> ', resolve));
+  try {
+    for (;;) {
+      const input = (await ask()).trim();
+      if (!input) continue;
+      if (/^(q|quit|exit|bye)$/i.test(input)) break;
+      if (/^new$/i.test(input)) { state = await openFresh(io); continue; }
+      try {
+        await say(state, input, io);
+      } catch (error) {
+        io.out.write(`\n${error.message || error}\n`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  return 0;
+}
+
+async function runOrbChat(args = [], io = { out: process.stdout }) {
+  const [verb, ...rest] = args;
+  if (verb === 'new') {
+    await openFresh(io);
+    return 0;
+  }
+  if (verb === 'say') {
+    const text = rest.join(' ').trim();
+    if (!text) {
+      io.out.write('Usage: atris orb say "what is on your mind"\n');
+      return 2;
+    }
+    await say(readState(), text, io);
+    return 0;
+  }
+  if (verb === 'pick') {
+    const state = readState();
+    if (!state.options.length) {
+      io.out.write('No choices yet. Start with: atris orb new\n');
+      return 2;
+    }
+    const number = Number(rest[0]);
+    if (!Number.isInteger(number) || number < 1 || number > state.options.length) {
+      io.out.write(`Pick a number from 1 to ${state.options.length}.\n`);
+      return 2;
+    }
+    await say(state, String(number), io);
+    return 0;
+  }
+  return interactive(io);
+}
+
+module.exports = { runOrbChat, resolveInput, turnBody, parseSseLines, readState, writeState, stateFile };

package/commands/orb.js

@@ -89,6 +89,7 @@ function showHelp() {
   console.log('Usage: atris orb [--once] [--json] [--engine claude|codex|fast]');
   console.log('       atris orb <n> | atris orb --pick <n>');
   console.log('       atris orb scorecard [--days N]');
+  console.log('       atris orb chat | atris orb new | atris orb say "text" | atris orb pick <n>');
   console.log('');
   console.log('Choose a next move while background engine jobs keep working.');
   console.log('--json emits {moves:[{n,label,command}]} and exits.');
@@ -162,6 +163,11 @@ async function runOrb(args = []) {
     return 0;
   }
 
+  if (['chat', 'say', 'pick', 'new'].includes(args[0])) {
+    const { runOrbChat } = require('./orb-chat');
+    return runOrbChat(args[0] === 'chat' ? args.slice(1) : args);
+  }
+
   if (args[0] === 'scorecard') {
     const parsed = parseOrbScorecardDays(args.slice(1));
     if (!parsed.ok) {

package/lib/engine-ask.js

@@ -14,6 +14,7 @@ const {
   canonicalEngineName,
   claudeModelId,
   currentClaudeModel,
+  DEFAULT_AGY_ASK_MODEL,
   engineFailureHealthStatus,
   setEngineHealth,
 } = require('./engine-registry');
@@ -252,6 +253,8 @@ function resolveAskModel(engine, modelName = '') {
       ? claudeModelId(requested)
       : currentClaudeModel(requested);
   }
+  // agy asks name their default so the receipt says which model answered.
+  if (engine === 'agy') return DEFAULT_AGY_ASK_MODEL;
   if (engine !== 'claude' && engine !== 'fable' && engine !== 'haiku') return '';
   // No model named: this is the unattended default, so it goes through the
   // spend gate. A model a person typed is their own yes.
@@ -334,19 +337,21 @@ function buildReadOnlyEngineInvocation(engineName, prompt, modelName = '', {
     };
   }
   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
-    // (verified live 2026-08-19). The sandbox keeps the run read-only while
-    // skip-permissions lets sandboxed reads proceed unattended.
+    // Plan mode hangs headless: a one-line ask timed out at 60s and at 300s,
+    // while edit mode answered in about 10s (measured 2026-11-11). So the ask
+    // runs in edit mode from an empty folder made for it (scratchCwd), where
+    // there is nothing real to edit; the prompt carries any repo context.
+    // No skip-permissions: edits land only in that folder, and anything else
+    // that would need a yes is refused instead of auto-approved.
     return {
       engine,
       bin: profile.bin,
+      scratchCwd: true,
       args: [
-        '--mode', 'plan',
+        '--mode', 'accept-edits',
         '--sandbox',
-        '--dangerously-skip-permissions',
         '--print-timeout', `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`,
-        ...(model ? ['--model', model] : []),
+        '--model', model || DEFAULT_AGY_ASK_MODEL,
         ...effortArgs,
         '-p', request,
       ],
@@ -422,6 +427,20 @@ function buildAskSpawnEnv(sourceEnv = process.env) {
   return env;
 }
 
+// An empty folder made for one ask, for engines whose ask runs in edit mode
+// (scratchCwd). The engine starts there instead of the repo, and the folder
+// is removed when the ask ends. Returns null for every other engine.
+function openAskScratch(invocation) {
+  if (!invocation || !invocation.scratchCwd) return null;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `atris-ask-${invocation.engine || 'engine'}-`));
+  return {
+    cwd: dir,
+    close() {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    },
+  };
+}
+
 function runAskProcess(invocation, {
   cwd = process.cwd(),
   timeoutMs = DEFAULT_ASK_TIMEOUT_MS,
@@ -433,6 +452,7 @@ function runAskProcess(invocation, {
 } = {}) {
   return new Promise((resolve) => {
     const startedAt = Date.now();
+    let scratch = null;
     const stdoutChunks = [];
     const stderrChunks = [];
     const stdoutState = { bytes: 0, truncated: false };
@@ -449,6 +469,7 @@ function runAskProcess(invocation, {
     const finish = (code, closeSignalValue, spawnError) => {
       if (finished) return;
       finished = true;
+      if (scratch) scratch.close();
       clearTimeout(timeoutTimer);
       if (hardStopTimer) clearTimeout(hardStopTimer);
       if (signal && typeof signal.removeEventListener === 'function') signal.removeEventListener('abort', onAbort);
@@ -515,8 +536,9 @@ function runAskProcess(invocation, {
     }
 
     try {
+      scratch = openAskScratch(invocation);
       child = spawnProcess(invocation.bin, invocation.args, {
-        cwd,
+        cwd: scratch ? scratch.cwd : cwd,
         env: buildAskSpawnEnv(env || invocation.env || process.env),
         detached: process.platform !== 'win32',
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -882,6 +904,7 @@ module.exports = {
   MAX_ASK_PROMPT_BYTES,
   parseEngineAskArgs,
   buildReadOnlyEngineInvocation,
+  openAskScratch,
   buildAskSpawnEnv,
   runAskProcess,
   runEngineAskJobs,

package/lib/engine-registry.js

@@ -158,6 +158,9 @@ function engineFailureHealthStatus(result) {
 // (not build, see hostedFallbacks), and only for someone logged in to atris.
 // role_order: the engine's place for one job when it differs from its
 // fallback_order. Haiku searches first wherever the claude CLI is installed.
+// An agy ask with no model named runs here: fast enough for a question,
+// where High is too slow (see the agy models list below).
+const DEFAULT_AGY_ASK_MODEL = 'gemini-4-carbon-medium';
 const ENGINE_SEED_META = Object.freeze({
   'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), models: Object.freeze(['atris fast']), duty: 'learning', fallback_order: 10, hosted: true }),
   // Test model on a capped free tier: a roster pick may use it, the router never hands it work.
@@ -191,6 +194,11 @@ const ENGINE_SEED_META = Object.freeze({
       // Matches `agy models` on agy 1.3.4, verified 2026-10-13.
       'gemini-4-argon-high',
       'gemini-4-argon-medium',
+      // Carbon on `agy models`, 2026-11-11. Medium is the ask default:
+      // High timed out at 150s on a 150-word question Medium answered in 25s.
+      'gemini-4-carbon-low',
+      DEFAULT_AGY_ASK_MODEL,
+      'gemini-4-carbon-high',
       'gemini-3.8-flash-high',
       'claude-opus-5-5-high',
       'claude-sonnet-5-5-high',
@@ -2491,6 +2499,7 @@ function engineDoctorReport(root = process.cwd()) {
 }
 
 module.exports = {
+  DEFAULT_AGY_ASK_MODEL,
   ENGINE_ROLES,
   ENGINE_JOBS,
   SMALL_BUILD_JOB,

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', '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',
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'memory', 'balance', 'film', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'channel', '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/roster-prep.js

@@ -17,7 +17,7 @@ const {
   resolveJobTeam,
 } = require('./engine-registry');
 const { spawnSync } = require('child_process');
-const { buildReadOnlyEngineInvocation, buildAskSpawnEnv, runAskProcess } = require('./engine-ask');
+const { buildReadOnlyEngineInvocation, buildAskSpawnEnv, openAskScratch, runAskProcess } = require('./engine-ask');
 const { appendRosterRun, parseRunUsage } = require('./roster-runs');
 const { startEngineRun } = require('./engine-resource');
 
@@ -136,15 +136,22 @@ async function defaultPrepAsk({ engine, model, effort, prompt, cwd, timeoutMs })
 // run synchronously). Same command, same answer shape as runAskProcess.
 function defaultPrepAskSync({ engine, model, effort, prompt, cwd, timeoutMs }) {
   const invocation = buildReadOnlyEngineInvocation(engine, prompt, model, { timeoutMs, effort });
-  const run = spawnSync(invocation.bin, invocation.args, {
-    cwd,
-    env: buildAskSpawnEnv(),
-    encoding: 'utf8',
-    timeout: timeoutMs,
-    killSignal: 'SIGKILL',
-    maxBuffer: 4 * 1024 * 1024,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  });
+  // An edit-mode ask (agy) never starts in the checkout, same as runAskProcess.
+  const scratch = openAskScratch(invocation);
+  let run;
+  try {
+    run = spawnSync(invocation.bin, invocation.args, {
+      cwd: scratch ? scratch.cwd : cwd,
+      env: buildAskSpawnEnv(),
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      killSignal: 'SIGKILL',
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } finally {
+    if (scratch) scratch.close();
+  }
   const stdout = String(run.stdout || '');
   const stderr = String(run.stderr || '');
   const timedOut = Boolean(run.error && run.error.code === 'ETIMEDOUT');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.21",
+  "version": "3.82.23",
   "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",