atris 3.15.57 → 3.16.0

package/ax

@@ -15,6 +15,11 @@ const BACKEND = {
   path: '/api/atris2/turn'
 };
 const DEFAULT_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
+const CODE_FAST = {
+  path: '/api/cursor/turn',
+  model: 'composer-2-5-fast',
+  publicBase: 'https://api.atris.ai'
+};
 const CONNECTION_STATUS_PATH = '/api/integrations/status';
 const CONNECTION_CAPABILITIES_PATH = '/api/atris2/connection-capabilities';
 const ATRIS2_CONNECTION_STATUS_PATH = '/api/atris2/connection-status';
@@ -53,10 +58,19 @@ const ANSI = {
   dim: '\x1b[2m',
   muted: '\x1b[90m',
   accent: '\x1b[36m',
-  ok: '\x1b[32m'
+  ok: '\x1b[32m',
+  magenta: '\x1b[35m'
 };
 
+const TIER_COLORS = { fast: '\x1b[32m', pro: '\x1b[36m', max: '\x1b[35m' };
+
+function tierColor(mode) {
+  return TIER_COLORS[mode] || ANSI.accent;
+}
+
 function modelForMode(mode) {
+  if (mode === 'code-fast') return CODE_FAST.model;
+  if (mode === 'max') return 'atris:max';
   return mode === 'fast' ? 'atris:fast' : 'atris:pro';
 }
 
@@ -74,34 +88,48 @@ function formatSeconds(totalSeconds) {
   return seconds ? `${minutes}m ${seconds}s` : `${minutes}m`;
 }
 
-function formatHeader({ mode = 'pro', cwd = process.cwd(), chat = false } = {}) {
-  const label = mode === 'fast' ? 'Atris 2 Fast' : 'Atris 2 Pro';
+function tierLabel(mode) {
+  if (mode === 'code-fast') return 'Atris Code Fast';
+  if (mode === 'max') return 'Atris 2 Max';
+  if (mode === 'fast') return 'Atris 2 Fast';
+  return 'Atris 2 Pro';
+}
+
+function formatHeader({ mode = 'pro', cwd = process.cwd(), chat = false } = {}, options = {}) {
   return [
-    `${label}${chat ? ' chat' : ''} (${modelForMode(mode)})`,
+    paint(`${tierLabel(mode)}${chat ? ' chat' : ''}`, [ANSI.bold, tierColor(normalizeMode(mode))], options),
     cwd,
-    chat ? 'exit with exit, quit, or :q' : '',
+    chat ? paint('type / for the menu · /fast /pro /max swap tiers · exit to leave', [ANSI.muted], options) : '',
   ].filter(Boolean).join('\n');
 }
 
 function formatUsage() {
   return [
-    'ax - Atris 2 local coding agent',
+    'ax - Atris local/code agent',
     '',
     'Usage:',
-    '  ax [--pro|--fast] [--local|--cloud] <message>',
-    '  ax [--pro|--fast] [--local|--cloud] --chat',
-    '  ax [--pro|--fast] --doctor',
-    '  ax [--fast] --benchmark',
+    '  ax [--max|--pro|--fast|--code-fast] [--local|--cloud] <message>',
+    '  ax [--max|--pro|--fast|--code-fast] [--local|--cloud] --chat',
+    '  ax [--max|--pro|--fast] --business <slug> [<message>|--chat]',
+    '  ax [--max|--pro|--fast|--code-fast] --doctor',
+    '  ax [--max|--fast] --benchmark',
     '',
     'Modes:',
+    '  --max   local workspace agent, highest reasoning, slowest turns',
     '  --pro   local workspace agent, deeper tool loop',
     '  --fast  local workspace agent, faster low-latency turns',
+    '  --code-fast  Atris Code Fast public lane',
     '  --local force local workspace tools',
     '  --cloud force authenticated cloud connectors/chat',
+    '  --business <slug>  run tools on that business cloud workspace (EC2)',
+    '  --verify <cmd>  gate the turn on this command passing (default: no verifier)',
     '',
     'Examples:',
     '  ax --pro find the config file and explain it',
     '  ax --fast what files are here',
+    '  ax --max refactor this module and verify the tests',
+    '  ax --max --verify "npm test" fix the failing suite',
+    '  ax --code-fast explain this error',
     '  ax --fast what is on my calendar today',
     '  ax --pro --chat',
   ].join('\n');
@@ -112,7 +140,9 @@ function timestampForFile(date = new Date()) {
 }
 
 function stripAnsi(value) {
-  return String(value || '').replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
+  return String(value || '')
+    .replace(/\x1b\]8;;[^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
 }
 
 function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', output = process.stdout } = {}) {
@@ -170,9 +200,48 @@ function backendPathUrl(pathname) {
   return new URL(pathname, backendBaseUrl()).toString();
 }
 
+function codeFastBaseUrl() {
+  return (process.env.AX_CODE_FAST_BACKEND_URL
+    || process.env.AX_CODE_FAST_API_BASE
+    || process.env.ATRIS_API_BASE
+    || CODE_FAST.publicBase).replace(/\/$/, '');
+}
+
+function codeFastUrl() {
+  return new URL(CODE_FAST.path, codeFastBaseUrl()).toString();
+}
+
+function isLoopbackUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return ['127.0.0.1', 'localhost', '::1'].includes(parsed.hostname);
+  } catch (_) {
+    return false;
+  }
+}
+
+function isCodeFastLocal(options = {}) {
+  const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
+  return route === 'local' && isLoopbackUrl(options.codeFastBaseUrl || codeFastBaseUrl());
+}
+
 function buildRunProfile(options = {}) {
-  const mode = options.mode === 'fast' ? 'fast' : 'pro';
+  const mode = normalizeMode(options.mode);
   const cwd = options.cwd || process.cwd();
+  if (mode === 'code-fast') {
+    const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
+    return {
+      endpoint: codeFastUrl(),
+      mode,
+      route,
+      model: CODE_FAST.model,
+      workspace_path: isCodeFastLocal(options) ? cwd : 'cloud scratch',
+      max_turns: 1,
+      streaming: false,
+      runtime: isCodeFastLocal(options) ? 'local Cursor SDK through backend' : 'authenticated Code Fast cloud scratch',
+      reasoning: 'Composer 2.5 fast lane; charges 10 credits per public turn'
+    };
+  }
   const route = resolveRoute(options.message || 'doctor', options);
   const payload = buildPayload(options.message || 'doctor', { mode, cwd, route });
   return {
@@ -184,15 +253,17 @@ function buildRunProfile(options = {}) {
     max_turns: payload.max_turns,
     streaming: true,
     runtime: route === 'cloud' ? 'authenticated cloud connectors/chat' : 'local workspace',
-    reasoning: mode === 'pro'
-      ? 'backend reports run row; Pro workspace tool loop uses API default medium'
-      : 'backend reports run row; Fast workspace tool loop uses provider default'
+    reasoning: mode === 'max'
+      ? 'backend reports run row; Max workspace tool loop uses high reasoning effort'
+      : mode === 'pro'
+        ? 'backend reports run row; Pro workspace tool loop uses API default medium'
+        : 'backend reports run row; Fast workspace tool loop uses provider default'
   };
 }
 
 function formatRunProfile(profile, options = {}) {
   const rows = [
-    ['mode', `${profile.mode} (${profile.model})`],
+    ['mode', profile.mode],
     ['endpoint', profile.endpoint],
     ['route', profile.route || 'auto'],
     ['workspace', formatPathSubject(profile.workspace_path, options)],
@@ -428,17 +499,75 @@ function resolveRoute(message, options = {}) {
   return 'local';
 }
 
-function formatPrompt() {
-  return '› ';
+function normalizeMode(mode) {
+  if (mode === 'code-fast' || mode === 'code') return 'code-fast';
+  if (mode === 'max') return 'max';
+  return mode === 'fast' ? 'fast' : 'pro';
 }
 
-function formatWorkingLine(ms) {
+function formatPrompt(mode, options = {}) {
+  if (!mode) return '› ';
+  const tier = normalizeMode(mode);
+  return `${paint(tier, [ANSI.bold, tierColor(tier)], options)} › `;
+}
+
+const TIER_COMMANDS = new Map([
+  ['/fast', 'fast'],
+  ['/pro', 'pro'],
+  ['/max', 'max'],
+]);
+
+function chatTierCommand(line) {
+  return TIER_COMMANDS.get(String(line || '').trim().toLowerCase()) || null;
+}
+
+const CHAT_COMMANDS = [
+  ['/fast', 'quick answers, lowest latency'],
+  ['/pro', 'deeper tool loop for real work'],
+  ['/max', 'highest reasoning for the hardest jobs'],
+  ['/help', 'show this menu'],
+  ['exit', 'leave chat'],
+];
+
+function chatMenu(options = {}) {
+  return CHAT_COMMANDS
+    .map(([name, desc]) => {
+      const tier = TIER_COMMANDS.get(name);
+      const color = tier ? tierColor(tier) : ANSI.accent;
+      return `  ${paint(name.padEnd(6), [color], options)}  ${paint(desc, [ANSI.muted], options)}`;
+    })
+    .join('\n');
+}
+
+function chatCompleter(line) {
+  const trimmed = String(line || '').trimStart().toLowerCase();
+  if (!trimmed.startsWith('/')) return [[], line];
+  const names = CHAT_COMMANDS.map(([name]) => name).filter(name => name.startsWith('/'));
+  const hits = names.filter(name => name.startsWith(trimmed));
+  return [hits.length ? hits : names, trimmed];
+}
+
+function formatWorkingLine(ms, verb, frame) {
   const totalSeconds = Math.max(1, Math.round((Number(ms) || 0) / 1000));
+  if (verb) return `${frame || '•'} ${verb}… (${formatSeconds(totalSeconds)} · ctrl-c to interrupt)`;
   return `• Working (${formatSeconds(totalSeconds)} • ctrl-c to interrupt)`;
 }
 
-function formatDoneLine(ms) {
-  return `— Worked for ${formatDuration(ms)} —`;
+function verbForTool(tool) {
+  const name = String(tool || '').toLowerCase();
+  if (name.includes('read')) return 'Reading';
+  if (name.includes('grep') || name.includes('glob') || name.includes('search')) return 'Searching';
+  if (name.includes('bash') || name.includes('command') || name.includes('run')) return 'Running';
+  if (name.includes('write') || name.includes('edit')) return 'Editing';
+  return 'Working';
+}
+
+function formatDoneLine(ms, credits) {
+  const base = `— Worked for ${formatDuration(ms)}`;
+  if (Number.isFinite(credits) && credits > 0) {
+    return `${base} · ${credits} ${credits === 1 ? 'credit' : 'credits'} —`;
+  }
+  return `${base} —`;
 }
 
 function useColor(options = {}) {
@@ -566,19 +695,29 @@ function truncateMiddle(value, limit = 120) {
   return `${text.slice(0, head)}...${text.slice(-tail)}`;
 }
 
+function hyperlinkPath(text, target, options = {}) {
+  if (!useColor(options)) return text;
+  const original = String(target || '').trim();
+  // Only link things that look like paths; skip prose like "cloud scratch".
+  if (!original || /\s/.test(original)) return text;
+  const href = `file://${encodeURI(path.resolve(original))}`;
+  return `\x1b]8;;${href}\x07${text}\x1b]8;;\x07`;
+}
+
 function formatPathSubject(value, options = {}) {
   const raw = truncateMiddle(String(value || '').trim(), options.limit || 120);
   if (!raw) return '';
   if (raw === '.' || raw === '/' || raw.endsWith('/')) {
-    return paint(raw, [ANSI.accent], options);
+    return hyperlinkPath(paint(raw, [ANSI.accent], options), value, options);
   }
 
   const slash = raw.lastIndexOf('/');
-  if (slash === -1) return paint(raw, [ANSI.bold, ANSI.accent], options);
+  if (slash === -1) return hyperlinkPath(paint(raw, [ANSI.bold, ANSI.accent], options), value, options);
 
   const parent = raw.slice(0, slash + 1);
   const filename = raw.slice(slash + 1);
-  return `${paint(parent, [ANSI.muted], options)}  ${paint(filename, [ANSI.bold, ANSI.accent], options)}`;
+  const text = `${paint(parent, [ANSI.muted], options)}  ${paint(filename, [ANSI.bold, ANSI.accent], options)}`;
+  return hyperlinkPath(text, value, options);
 }
 
 function formatAuxRow(label, value, options = {}) {
@@ -591,6 +730,9 @@ function createProgressReporter(output, options = {}) {
   const enabled = options.showProgress !== false;
   const isTty = Boolean(output && output.isTTY);
   const startedAt = Date.now();
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let frameIndex = 0;
+  let verb = 'Working';
   let interval = null;
   let timeout = null;
   let shown = false;
@@ -598,11 +740,11 @@ function createProgressReporter(output, options = {}) {
 
   const render = () => {
     if (!enabled || closed) return;
-    const line = formatWorkingLine(Date.now() - startedAt);
     if (isTty) {
-      output.write(`\r${line}\x1b[K`);
+      const frame = paint(frames[frameIndex++ % frames.length], [ANSI.accent], output);
+      output.write(`\r${formatWorkingLine(Date.now() - startedAt, verb, frame)}\x1b[K`);
     } else if (!shown) {
-      output.write(`${line}\n`);
+      output.write(`${formatWorkingLine(Date.now() - startedAt)}\n`);
     }
     shown = true;
   };
@@ -612,9 +754,12 @@ function createProgressReporter(output, options = {}) {
       if (!enabled) return;
       timeout = setTimeout(() => {
         render();
-        if (isTty) interval = setInterval(render, 1000);
+        if (isTty) interval = setInterval(render, 120);
       }, 700);
     },
+    setVerb(next) {
+      verb = next || 'Working';
+    },
     clear() {
       if (!isTty || !shown || closed) return;
       output.write('\r\x1b[K');
@@ -642,22 +787,34 @@ function parseSseBlock(block) {
   return JSON.parse(data);
 }
 
-function summarizeToolInput(block) {
-  const options = arguments[1] || {};
-  const tool = block.tool || 'tool';
+function summarizeToolArgs(block, options = {}) {
   const input = block.input || {};
-  const toolName = paint(tool, [ANSI.bold], options);
   const pathValue = input.file_path || input.path;
-  if (input.command) return `${toolName}  ${truncateMiddle(input.command, 120)}`;
+  if (input.command) return truncateMiddle(input.command, 120);
   if (input.pattern || input.query) {
     const pattern = truncateMiddle(input.pattern || input.query, 80);
-    return pathValue
-      ? `${toolName}  ${pattern}  in  ${formatPathSubject(pathValue, options)}`
-      : `${toolName}  ${pattern}`;
+    return pathValue ? `${pattern}  in  ${formatPathSubject(pathValue, options)}` : pattern;
   }
-  if (pathValue) return `${toolName}  ${formatPathSubject(pathValue, options)}`;
+  if (pathValue) return formatPathSubject(pathValue, options);
   const subject = input.type || '';
-  return subject ? `${toolName}  ${String(subject).slice(0, 120)}` : toolName;
+  return subject ? String(subject).slice(0, 120) : '';
+}
+
+function summarizeToolInput(block) {
+  const options = arguments[1] || {};
+  const toolName = paint(block.tool || 'tool', [ANSI.bold], options);
+  const args = summarizeToolArgs(block, options);
+  return args ? `${toolName}  ${args}` : toolName;
+}
+
+function formatToolCallLine(block, options = {}) {
+  const tool = paint(block.tool || 'tool', [ANSI.bold], options);
+  const args = summarizeToolArgs(block, options);
+  return `${paint('●', [ANSI.ok], options)} ${tool}(${args})`;
+}
+
+function formatToolResultLine(summary, options = {}) {
+  return `  ${paint('⎿', [ANSI.muted], options)}  ${summary}`;
 }
 
 function summarizeToolResult(result) {
@@ -679,14 +836,24 @@ function summarizeToolResult(result) {
       const where = parsed.path ? `  in  ${formatPathSubject(parsed.path, options)}` : '';
       return `${parts.join(' / ')}${where}`;
     }
+    if (typeof parsed.content === 'string' && parsed.content) {
+      const lines = parsed.content.split('\n').length;
+      const where = parsed.path ? `  ${formatPathSubject(parsed.path, options)}` : '';
+      return `${lines} ${lines === 1 ? 'line' : 'lines'}${where}`;
+    }
     if (parsed.path && parsed.status) return `${parsed.status}  ${formatPathSubject(parsed.path, options)}`;
     if (parsed.path) return formatPathSubject(parsed.path, options);
     if (parsed.status) return parsed.status;
   } catch (_) {
-    // Bash output and older streams can be plain text.
+    // Truncated relay JSON and bash output fall through to the text path.
   }
 
-  return content.length > 120 ? `${content.slice(0, 117)}...` : content;
+  const head = content.match(/^\{"status":\s*"(\w+)",\s*"path":\s*"([^"]+)"/);
+  if (head) return `${head[1]}  ${formatPathSubject(head[2], options)}`;
+
+  const lines = content.split('\n');
+  const first = lines[0].length > 120 ? `${lines[0].slice(0, 117)}...` : lines[0];
+  return lines.length > 1 ? `${first}  … +${lines.length - 1} lines` : first;
 }
 
 function formatStatusMessage(message) {
@@ -698,10 +865,9 @@ function formatStatusMessage(message) {
 
 function formatSystemInit(event, options = {}) {
   const runtime = event.tool_runtime || {};
-  const model = runtime.tool_model || runtime.chat_model || event.model || '';
   const mode = runtime.mode ? String(runtime.mode).replace(/_/g, ' ') : '';
   const thinking = runtime.reasoning_effort ? `thinking ${runtime.reasoning_effort}` : '';
-  const parts = [mode || 'runtime', model, thinking].filter(Boolean);
+  const parts = [mode || 'runtime', thinking].filter(Boolean);
   return parts.length ? parts.join('  ') : null;
 }
 
@@ -711,6 +877,7 @@ function clearRetriedText(state) {
   state.wroteText = false;
   state.lastChar = '\n';
   state.inAuxBlock = false;
+  state.needsBullet = true;
   resetMarkdownState(state);
 }
 
@@ -729,6 +896,10 @@ function flushPendingText(state, output) {
   if (!state.pendingText && !hasMarkdownRemainder) return;
   stopProgress(state);
   if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
+  if (state.pendingText && state.needsBullet && output && output.isTTY) {
+    output.write('● ');
+    state.needsBullet = false;
+  }
   if (state.pendingText) output.write(output && output.isTTY ? renderTerminalMarkdown(state.pendingText, output) : state.pendingText);
   const flushedMarkdown = hasMarkdownRemainder ? flushStreamingMarkdown(state, output) : '';
   state.wroteText = true;
@@ -744,6 +915,10 @@ function writeStreamingText(state, output, content) {
   stopProgress(state);
   if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
   const rendered = renderStreamingMarkdown(state, content, output);
+  if (rendered && state.needsBullet && output.isTTY) {
+    output.write('● ');
+    state.needsBullet = false;
+  }
   if (rendered) output.write(rendered);
   state.wroteText = true;
   state.wroteActivity = true;
@@ -753,13 +928,15 @@ function writeStreamingText(state, output, content) {
 
 function writeAuxLine(state, output, line) {
   if (!line) return;
-  stopProgress(state);
+  // Keep the spinner alive between tool lines — just clear it off the row.
+  if (state.progress) state.progress.clear();
   if (state.wroteText && state.lastChar !== '\n') output.write('\n');
   if (!state.inAuxBlock && state.wroteActivity && state.lastChar === '\n') output.write('\n');
   output.write(`${line}\n`);
   state.wroteActivity = true;
   state.lastChar = '\n';
   state.inAuxBlock = true;
+  state.needsBullet = true;
 }
 
 function compactHistory(history, limit = 8) {
@@ -784,16 +961,23 @@ function buildMessage(message, history = []) {
 }
 
 function buildPayload(message, options = {}) {
-  const mode = options.mode === 'fast' ? 'fast' : 'pro';
-  const route = resolveRoute(message, options);
+  const mode = normalizeMode(options.mode);
+  const route = options.business ? 'local' : resolveRoute(message, options);
   const local = route !== 'cloud';
+  const verifyCommand = String(options.verify || '').trim();
   const payload = {
     message: buildMessage(message, options.history || []),
     model: modelForMode(mode),
-    max_turns: local ? (mode === 'pro' ? 14 : 8) : 1,
-    verify_command: 'true'
+    max_turns: local ? (mode === 'fast' ? 8 : 14) : 1,
+    verify_command: verifyCommand || 'true'
   };
-  if (local) {
+  if (options.business) {
+    // Business cloud workspace: the model loop stays on the backend and every
+    // file/bash tool call relays here, executing on the business EC2 via the
+    // /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();
   }
   if (options.connectionContext) {
@@ -805,18 +989,40 @@ function buildPayload(message, options = {}) {
   if (!local && connectorWriteIntent(message)) {
     payload.allow_external_actions = true;
     payload.cleanup_external_actions = true;
-    payload.max_turns = mode === 'pro' ? 4 : 2;
+    payload.max_turns = mode === 'fast' ? 2 : 4;
+  }
+  return payload;
+}
+
+function buildCodeFastPayload(message, options = {}) {
+  const payload = {
+    message: buildMessage(message, options.history || []),
+    model: CODE_FAST.model,
+    timeout_seconds: Number(options.timeoutSeconds || 180)
+  };
+  if (isCodeFastLocal(options)) {
+    payload.workspace_path = options.cwd || process.cwd();
   }
   return payload;
 }
 
+function codeFastWorkspaceNotice(result) {
+  const workspace = result && typeof result === 'object' ? result.workspace || {} : {};
+  const billing = result && typeof result === 'object' ? result.billing || {} : {};
+  const mode = workspace.mode || billing.workspace_mode || '';
+  const persistence = workspace.persistence || billing.workspace_persistence || '';
+  if (mode === 'cloud_scratch' || persistence === 'ephemeral') {
+    return 'cloud scratch files are temporary and are not saved to your Mac';
+  }
+  return null;
+}
+
 function handleEvent(event, state, output) {
   if (!event || typeof event !== 'object') return;
   state.events.push(event);
 
   if (event.type === 'system_init') {
     state.runtime = event;
-    writeAuxLine(state, output, formatAuxRow('run', formatSystemInit(event, output), output));
     return;
   }
 
@@ -831,7 +1037,10 @@ function handleEvent(event, state, output) {
     for (const block of event.blocks) {
       if (block && block.type === 'tool_use') {
         flushPendingText(state, output);
-        writeAuxLine(state, output, formatAuxRow('tool', summarizeToolInput(block, output), output));
+        if (state.lastAux === 'result' && state.inAuxBlock) output.write('\n');
+        writeAuxLine(state, output, formatToolCallLine(block, output));
+        state.lastAux = 'call';
+        if (state.progress && state.progress.setVerb) state.progress.setVerb(verbForTool(block.tool));
       }
     }
     return;
@@ -840,18 +1049,41 @@ function handleEvent(event, state, output) {
   if (event.type === 'tool_results' && Array.isArray(event.results)) {
     for (const result of event.results) {
       flushPendingText(state, output);
-      writeAuxLine(state, output, formatAuxRow('ok', summarizeToolResult(result, output), output));
+      writeAuxLine(state, output, formatToolResultLine(summarizeToolResult(result, output), output));
+      state.lastAux = 'result';
+    }
+    return;
+  }
+
+  if (event.type === 'tool_call_request') {
+    flushPendingText(state, output);
+    const args = event.args || {};
+    const cloudBlock = { tool: `cloud:${args.type || event.name || 'tool'}`, input: { command: args.command, path: args.path } };
+    if (state.lastAux === 'result' && state.inAuxBlock) output.write('\n');
+    writeAuxLine(state, output, formatToolCallLine(cloudBlock, output));
+    state.lastAux = 'call';
+    if (state.progress && state.progress.setVerb) state.progress.setVerb(verbForTool(args.type || event.name));
+    if (state.relay) {
+      // Relayed calls run sequentially: the backend awaits each tool-result
+      // before continuing its loop, so a promise chain preserves order.
+      state.relay.chain = state.relay.chain
+        .then(() => state.relay.execute(event.name, args))
+        .catch((err) => ({ status: 'error', error: String(err.message || err).slice(0, 500) }))
+        .then((result) => state.relay.post(event.call_id, result))
+        .catch((err) => state.errors.push(`tool relay failed: ${err.message}`));
     }
     return;
   }
 
   if (event.type === 'status' && event.message && event.message !== 'complete') {
-    if (event.message === 'retrying_with_required_local_tool') {
+    // Any retry status supersedes the draft answer already buffered — drop it
+    // silently instead of printing the abandoned text plus an info row.
+    if (/^retrying/i.test(event.message)) {
       clearRetriedText(state);
       return;
     }
     flushPendingText(state, output);
-    writeAuxLine(state, output, formatAuxRow('info', formatStatusMessage(event.message), output));
+    writeAuxLine(state, output, paint(`· ${formatStatusMessage(event.message)}`, [ANSI.muted], output));
     return;
   }
 
@@ -869,7 +1101,7 @@ function handleEvent(event, state, output) {
 }
 
 async function postTurn(message, options = {}) {
-  const route = resolveRoute(message, options);
+  const route = options.business ? 'local' : resolveRoute(message, options);
   const local = route !== 'cloud';
   const token = authToken();
   const shouldSendConnectionContext = options.connectionContext
@@ -883,7 +1115,10 @@ async function postTurn(message, options = {}) {
   const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
-  const timeoutMs = payload.model === 'atris:pro' ? 180000 : 60000;
+  // Relayed business turns wait on EC2 terminal calls (up to 60s each) with no
+  // SSE traffic in between, so the socket-idle timeout needs more headroom.
+  const baseTimeoutMs = payload.model === 'atris:max' ? 300000 : payload.model === 'atris:pro' ? 180000 : 60000;
+  const timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
   const turnUrl = new URL(backendUrl());
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
@@ -897,9 +1132,16 @@ async function postTurn(message, options = {}) {
     lastChar: '\n',
     progress: null,
     inAuxBlock: false,
+    needsBullet: true,
+    lastAux: '',
     markdownMode: 'normal',
     markdownBuffer: '',
-    markdownCarry: ''
+    markdownCarry: '',
+    relay: options.business ? {
+      chain: Promise.resolve(),
+      execute: options.business.executor,
+      post: (callId, result) => options.business.postToolResult(callId, result, backendBaseUrl())
+    } : null
   };
 
   return new Promise((resolve, reject) => {
@@ -993,8 +1235,121 @@ async function postTurn(message, options = {}) {
   });
 }
 
+async function postCodeFastTurn(message, options = {}) {
+  const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
+  if (route === 'local' && !isCodeFastLocal(options)) {
+    throw new Error('Atris Code Fast local workspace requires AX_CODE_FAST_BACKEND_URL=http://127.0.0.1:8000; use --cloud for the public lane.');
+  }
+
+  const payload = buildCodeFastPayload(message, { ...options, route });
+  const postData = JSON.stringify(payload);
+  const output = options.output || process.stdout;
+  const token = authToken();
+  const timeoutMs = Math.max(10000, Math.min(600000, Number(payload.timeout_seconds || 180) * 1000));
+  const turnUrl = new URL(codeFastUrl());
+  const transport = turnUrl.protocol === 'https:' ? https : http;
+  const state = {
+    events: [],
+    errors: [],
+    output: '',
+    pendingText: '',
+    wroteText: false,
+    wroteActivity: false,
+    durationMs: 0,
+    lastChar: '\n',
+    progress: null,
+    inAuxBlock: false,
+    needsBullet: true,
+    lastAux: '',
+    markdownMode: 'normal',
+    markdownBuffer: '',
+    markdownCarry: ''
+  };
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const startedAt = Date.now();
+    state.progress = createProgressReporter(output, options);
+    state.progress.start();
+
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (state.progress) state.progress.stop();
+      state.progress = null;
+      state.durationMs = Date.now() - startedAt;
+      if (error) reject(error);
+      else resolve(value);
+    };
+
+    const req = transport.request({
+      hostname: turnUrl.hostname,
+      port: turnUrl.port || (turnUrl.protocol === 'https:' ? 443 : 80),
+      path: `${turnUrl.pathname}${turnUrl.search}`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData),
+        Accept: 'application/json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {})
+      }
+    }, (res) => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const rawBody = Buffer.concat(chunks).toString('utf8');
+        let parsed = null;
+        try {
+          parsed = rawBody ? JSON.parse(rawBody) : null;
+        } catch (_) {
+          parsed = null;
+        }
+
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          const detail = parsed && (parsed.detail || parsed.error || parsed.message);
+          finish(new Error(detail || rawBody || `HTTP ${res.statusCode}`));
+          return;
+        }
+
+        const text = String((parsed && (parsed.text || parsed.result || parsed.message)) || '').trim();
+        if (text) {
+          state.output = text;
+          if (output && output.isTTY) output.write(renderTerminalMarkdown(text, output));
+          else output.write(text);
+          state.wroteText = true;
+          state.wroteActivity = true;
+          state.lastChar = text.slice(-1);
+        }
+        const notice = codeFastWorkspaceNotice(parsed);
+        if (notice) {
+          if (state.lastChar && state.lastChar !== '\n') output.write('\n');
+          output.write(`${formatAuxRow('note', notice, output)}\n`);
+          state.wroteActivity = true;
+          state.lastChar = '\n';
+        }
+        state.events.push({ type: 'result', result: text, raw: parsed });
+        state.billing = parsed && parsed.billing ? parsed.billing : null;
+        if (parsed && parsed.duration_ms) state.durationMs = parsed.duration_ms;
+        finish(null, state);
+      });
+    });
+
+    req.on('error', finish);
+    req.setTimeout(timeoutMs, () => {
+      finish(new Error(`Request timeout after ${timeoutMs / 1000}s`));
+      req.destroy();
+    });
+    req.write(postData);
+    req.end();
+  });
+}
+
+function turnFunctionForMode(mode) {
+  return normalizeMode(mode) === 'code-fast' ? postCodeFastTurn : postTurn;
+}
+
 async function chat(options = {}) {
-  const mode = options.mode === 'fast' ? 'fast' : 'pro';
+  let mode = normalizeMode(options.mode);
   const cwd = options.cwd || process.cwd();
   const input = options.input || process.stdin;
   const baseOutput = options.output || process.stdout;
@@ -1002,7 +1357,7 @@ async function chat(options = {}) {
   const output = logger ? logger.output : baseOutput;
   const history = [];
 
-  output.write(`${formatHeader({ mode, cwd, chat: true })}\n\n`);
+  output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
   if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
 
   const runLine = async (line) => {
@@ -1010,11 +1365,29 @@ async function chat(options = {}) {
     if (!trimmed) return false;
     if (EXIT_WORDS.has(trimmed.toLowerCase())) return true;
 
+    if (trimmed === '/' || trimmed.toLowerCase() === '/help') {
+      output.write(`${chatMenu(output)}\n\n`);
+      return false;
+    }
+
+    const tier = chatTierCommand(trimmed);
+    if (tier) {
+      mode = tier;
+      if (logger) logger.write(`${trimmed}\n`);
+      output.write(`${paint(`· ${tierLabel(mode)}`, [tierColor(mode)], output)}\n\n`);
+      return false;
+    }
+
+    if (trimmed.startsWith('/')) {
+      output.write(`${chatMenu(output)}\n\n`);
+      return false;
+    }
+
     if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
     output.write('\n');
-    const result = await postTurn(trimmed, { mode, cwd, history, output });
+    const result = await turnFunctionForMode(mode)(trimmed, { mode, cwd, history, output, route: options.route, business: options.business, verify: options.verify });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
-    output.write(`${formatDoneLine(result.durationMs)}\n\n`);
+    output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n\n`);
     history.push({ role: 'user', content: trimmed });
     history.push({ role: 'assistant', content: result.output || '' });
     return false;
@@ -1029,8 +1402,8 @@ async function chat(options = {}) {
     return;
   }
 
-  const rl = readline.createInterface({ input, output: baseOutput });
-  const ask = () => new Promise(resolve => rl.question(formatPrompt(mode), resolve));
+  const rl = readline.createInterface({ input, output: baseOutput, completer: chatCompleter });
+  const ask = () => new Promise(resolve => rl.question(formatPrompt(mode, baseOutput), resolve));
   while (true) {
     const line = await ask();
     if (await runLine(line)) {
@@ -1066,6 +1439,14 @@ function receiptFromState(state) {
   return event ? event.receipt : null;
 }
 
+function creditsFromState(state) {
+  const receipt = receiptFromState(state);
+  const billing = receipt && receipt.billing;
+  if (!billing || billing.billed === false) return null;
+  const credits = Number(billing.credits_charged);
+  return Number.isFinite(credits) && credits > 0 ? credits : null;
+}
+
 function toolEventsFromState(state) {
   const receipt = receiptFromState(state);
   if (receipt && Array.isArray(receipt.tool_events)) return receipt.tool_events;
@@ -1096,13 +1477,14 @@ async function runBenchmarkCase(label, fn, results, output) {
 }
 
 async function runBenchmark(options = {}) {
-  const mode = options.mode === 'pro' ? 'pro' : 'fast';
+  const normalized = normalizeMode(options.mode);
+  const mode = normalized === 'code-fast' ? 'fast' : normalized;
   const output = options.output || process.stdout;
   const results = [];
   const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'ax-atris2-benchmark-'));
   const localOut = () => bufferedOutput();
 
-  output.write(`Atris 2 ${mode === 'fast' ? 'Fast' : 'Pro'} benchmark\n`);
+  output.write(`Atris 2 ${mode === 'fast' ? 'Fast' : mode === 'max' ? 'Max' : 'Pro'} benchmark\n`);
   output.write(`${backendUrl()}\n\n`);
 
   try {
@@ -1221,17 +1603,74 @@ async function main() {
     return;
   }
 
-  const mode = args.includes('--fast') ? 'fast' : 'pro';
+  // --business <slug>: chat against that business's cloud workspace. The flag
+  // takes a value, so splice the pair out before building the prompt.
+  let businessSlug = null;
+  const bizIdx = args.indexOf('--business');
+  if (bizIdx !== -1) {
+    businessSlug = String(args[bizIdx + 1] || '').toLowerCase();
+    if (!/^[a-z0-9-]+$/.test(businessSlug)) {
+      console.error('Usage: ax --business <slug> [prompt]');
+      process.exit(1);
+    }
+    args.splice(bizIdx, 2);
+  }
+
+  // --verify <cmd>: opt-in turn verifier. The flag takes a value, so splice
+  // the pair out before building the prompt.
+  let verify = '';
+  const verifyIdx = args.indexOf('--verify');
+  if (verifyIdx !== -1) {
+    verify = String(args[verifyIdx + 1] || '').trim();
+    if (!verify) {
+      console.error('Usage: ax --verify "<cmd>" [prompt]');
+      process.exit(1);
+    }
+    args.splice(verifyIdx, 2);
+  }
+
+  const mode = args.includes('--code-fast') || args.includes('--code') ? 'code-fast' : args.includes('--max') ? 'max' : args.includes('--fast') ? 'fast' : 'pro';
   const doctor = args.includes('--doctor');
   const benchmark = args.includes('--benchmark');
   const forceCloud = args.includes('--cloud');
   const forceLocal = args.includes('--local');
   const route = forceCloud ? 'cloud' : forceLocal ? 'local' : 'auto';
   const prompt = args
-    .filter(arg => !['--fast', '--pro', '--chat', '--doctor', '--benchmark', '--local', '--cloud', '--help', '-h'].includes(arg))
+    .filter(arg => !['--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--benchmark', '--local', '--cloud', '--help', '-h'].includes(arg))
     .join(' ')
     .trim();
 
+  let business = null;
+  if (businessSlug) {
+    if (normalizeMode(mode) === 'code-fast') {
+      console.error('--business is not supported with --code-fast');
+      process.exit(1);
+    }
+    const creds = loadCredentials();
+    if (!creds || !creds.token) {
+      console.error('Not logged in. Run: atris login');
+      process.exit(1);
+    }
+    const { resolveBusiness, ensureAwake } = require('./commands/terminal');
+    const { makeCloudExecutor, postToolResult } = require('./commands/workflow');
+    const biz = await resolveBusiness(creds.token, businessSlug);
+    if (!biz || !biz.workspaceId) {
+      console.error(`Business "${businessSlug}" not found or has no workspace.`);
+      process.exit(1);
+    }
+    const awake = await ensureAwake(creds.token, biz.businessId);
+    if (!awake) {
+      console.error('Business computer did not become ready in time.');
+      process.exit(1);
+    }
+    business = {
+      slug: businessSlug,
+      executor: makeCloudExecutor({ token: creds.token, businessId: biz.businessId, workspaceId: biz.workspaceId, slug: businessSlug }),
+      postToolResult
+    };
+    console.log(`cloud workspace: ${biz.businessName || businessSlug}`);
+  }
+
   try {
     if (benchmark) {
       await runBenchmark({ mode, cwd: process.cwd(), output: process.stdout });
@@ -1239,22 +1678,22 @@ async function main() {
     }
 
     if (doctor) {
-      console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }));
+      console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
       console.log('');
       console.log(formatRunProfile(buildRunProfile({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route }), process.stdout));
       return;
     }
 
     if (!prompt || args.includes('--chat')) {
-      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route });
+      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
       return;
     }
 
-    console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }));
+    console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
     console.log('');
-    const result = await postTurn(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route });
+    const result = await turnFunctionForMode(mode)(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
     console.log('');
-    console.log(formatDoneLine(result.durationMs));
+    console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
     printBackendHint();
@@ -1271,11 +1710,19 @@ module.exports = {
   authUserId,
   backendBaseUrl,
   backendUrl,
+  buildCodeFastPayload,
   buildPayload,
   cachedIntegrationStatus,
   buildConnectionContext,
   buildRunProfile,
   chat,
+  chatCompleter,
+  chatMenu,
+  chatTierCommand,
+  codeFastWorkspaceNotice,
+  creditsFromState,
+  codeFastBaseUrl,
+  codeFastUrl,
   createRunLogger,
   createProgressReporter,
   formatDoneLine,
@@ -1291,11 +1738,13 @@ module.exports = {
   handleEvent,
   modelForMode,
   parseSseBlock,
+  postCodeFastTurn,
   postTurn,
   renderStreamingMarkdown,
   renderTerminalMarkdown,
   resolveRoute,
   runBenchmark,
   summarizeToolInput,
-  summarizeToolResult
+  summarizeToolResult,
+  tierLabel
 };