atris 3.15.23 → 3.15.30

package/ax

@@ -0,0 +1,1083 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { loadCredentials } = require('./utils/auth');
+
+const EXIT_WORDS = new Set(['exit', 'quit', ':q']);
+const BACKEND = {
+  host: '127.0.0.1',
+  port: 8000,
+  path: '/api/atris2/turn'
+};
+const DEFAULT_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
+const CONNECTION_STATUS_PATH = '/api/integrations/status';
+const CONNECTION_CAPABILITIES_PATH = '/api/atris2/connection-capabilities';
+const ATRIS2_CONNECTION_STATUS_PATH = '/api/atris2/connection-status';
+const CONNECTOR_NAMES = {
+  gmail: 'Gmail',
+  google_calendar: 'Google Calendar',
+  google_drive: 'Google Drive',
+  google_docs: 'Google Docs',
+  github: 'GitHub',
+  slack: 'Slack',
+  linear: 'Linear',
+  notion: 'Notion',
+  hubspot: 'HubSpot',
+  twitter: 'Twitter',
+  microsoft: 'Microsoft',
+  discord: 'Discord',
+  jira: 'Jira',
+  linkedin: 'LinkedIn',
+  whatsapp: 'WhatsApp',
+  salesforce: 'Salesforce'
+};
+const CONNECTOR_SCOPES = {
+  gmail: ['mail'],
+  google_calendar: ['calendar'],
+  google_drive: ['drive'],
+  google_docs: ['docs'],
+  github: ['repos', 'issues', 'pull_requests'],
+  slack: ['messages'],
+  linear: ['issues'],
+  notion: ['pages', 'databases'],
+  hubspot: ['crm']
+};
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  muted: '\x1b[90m',
+  accent: '\x1b[36m',
+  ok: '\x1b[32m'
+};
+
+function modelForMode(mode) {
+  return mode === 'fast' ? 'atris:fast' : 'atris:pro';
+}
+
+function formatDuration(ms) {
+  const value = Number(ms) || 0;
+  if (value < 1000) return `${Math.max(0, Math.round(value))}ms`;
+  const totalSeconds = Math.max(1, Math.round(value / 1000));
+  return formatSeconds(totalSeconds);
+}
+
+function formatSeconds(totalSeconds) {
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  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';
+  return [
+    `${label}${chat ? ' chat' : ''} (${modelForMode(mode)})`,
+    cwd,
+    chat ? 'exit with exit, quit, or :q' : '',
+  ].filter(Boolean).join('\n');
+}
+
+function formatUsage() {
+  return [
+    'ax - Atris 2 local coding agent',
+    '',
+    'Usage:',
+    '  ax [--pro|--fast] [--local|--cloud] <message>',
+    '  ax [--pro|--fast] [--local|--cloud] --chat',
+    '  ax [--pro|--fast] --doctor',
+    '  ax [--fast] --benchmark',
+    '',
+    'Modes:',
+    '  --pro   local workspace agent, deeper tool loop',
+    '  --fast  local workspace agent, faster low-latency turns',
+    '  --local force local workspace tools',
+    '  --cloud force authenticated cloud connectors/chat',
+    '',
+    'Examples:',
+    '  ax --pro find the config file and explain it',
+    '  ax --fast what files are here',
+    '  ax --fast what is on my calendar today',
+    '  ax --pro --chat',
+  ].join('\n');
+}
+
+function backendBaseUrl() {
+  return (process.env.AX_BACKEND_URL
+    || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL
+    || process.env.OBELISK_ATRIS2_BACKEND_URL
+    || DEFAULT_BACKEND_BASE).replace(/\/$/, '');
+}
+
+function backendUrl() {
+  return new URL(BACKEND.path, backendBaseUrl()).toString();
+}
+
+function backendPathUrl(pathname) {
+  return new URL(pathname, backendBaseUrl()).toString();
+}
+
+function buildRunProfile(options = {}) {
+  const mode = options.mode === 'fast' ? 'fast' : 'pro';
+  const cwd = options.cwd || process.cwd();
+  const route = resolveRoute(options.message || 'doctor', options);
+  const payload = buildPayload(options.message || 'doctor', { mode, cwd, route });
+  return {
+    endpoint: backendUrl(),
+    mode,
+    route,
+    model: payload.model,
+    workspace_path: payload.workspace_path || 'cloud',
+    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'
+  };
+}
+
+function formatRunProfile(profile, options = {}) {
+  const rows = [
+    ['mode', `${profile.mode} (${profile.model})`],
+    ['endpoint', profile.endpoint],
+    ['route', profile.route || 'auto'],
+    ['workspace', formatPathSubject(profile.workspace_path, options)],
+    ['turns', String(profile.max_turns)],
+    ['streaming', profile.streaming ? 'yes' : 'no'],
+    ['runtime', profile.runtime],
+    ['thinking', profile.reasoning],
+  ];
+  return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
+}
+
+function canonicalConnectorId(value) {
+  return String(value || '').trim().toLowerCase().replace(/-/g, '_');
+}
+
+function connectorDisplayName(id) {
+  const key = canonicalConnectorId(id);
+  if (CONNECTOR_NAMES[key]) return CONNECTOR_NAMES[key];
+  return key.split('_').map(part => part ? part[0].toUpperCase() + part.slice(1) : '').join(' ');
+}
+
+function authToken() {
+  if (process.env.OBELISK_AUTH_TOKEN) return process.env.OBELISK_AUTH_TOKEN;
+  if (process.env.ATRIS_TOKEN) return process.env.ATRIS_TOKEN;
+  try {
+    const creds = loadCredentials();
+    return creds && creds.token ? creds.token : '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function authUserId() {
+  if (process.env.OBELISK_USER_ID) return process.env.OBELISK_USER_ID;
+  if (process.env.ATRIS_USER_ID) return process.env.ATRIS_USER_ID;
+  try {
+    const creds = loadCredentials();
+    return creds && creds.user_id ? creds.user_id : '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function isLoopbackBackend() {
+  try {
+    const parsed = new URL(backendBaseUrl());
+    return ['127.0.0.1', 'localhost', '::1'].includes(parsed.hostname);
+  } catch (_) {
+    return false;
+  }
+}
+
+function requestJson(pathname, { token = authToken(), timeoutMs = 6000 } = {}) {
+  const url = backendPathUrl(pathname);
+  const parsed = new URL(url);
+  const transport = parsed.protocol === 'https:' ? https : http;
+  return new Promise((resolve) => {
+    const req = transport.request({
+      method: 'GET',
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: `${parsed.pathname}${parsed.search}`,
+      headers: {
+        Accept: 'application/json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {})
+      }
+    }, (res) => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        try {
+          resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data: text ? JSON.parse(text) : null, text });
+        } catch (_) {
+          resolve({ ok: false, status: res.statusCode, data: null, text });
+        }
+      });
+    });
+    req.on('error', error => resolve({ ok: false, status: 0, data: null, text: '', error: error.message }));
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      resolve({ ok: false, status: 0, data: null, text: '', error: `timeout after ${timeoutMs}ms` });
+    });
+    req.end();
+  });
+}
+
+function defaultAuthority(id) {
+  const key = canonicalConnectorId(id);
+  if (key === 'gmail') return { list_messages: 'read_only', get_message: 'read_only', send_message: 'approval_required' };
+  if (key === 'google_calendar') return { list_events: 'read_only', get_event: 'read_only', create_event: 'approval_required' };
+  if (key === 'google_drive') return { list_files: 'read_only', search_files: 'read_only', download_file: 'read_only', upload_file: 'approval_required' };
+  if (key === 'google_docs') return { list_documents: 'read_only', get_document: 'read_only', create_document: 'approval_required' };
+  if (key === 'github') return { list_repos: 'read_only', get_repo: 'read_only', list_issues: 'read_only', create_issue: 'approval_required' };
+  if (key === 'slack') return { list_channels: 'read_only', search_messages: 'read_only', post_message: 'approval_required' };
+  if (key === 'linear') return { list_issues: 'read_only', get_issue: 'read_only', create_issue: 'approval_required' };
+  if (key === 'notion') return { search: 'read_only', get_page: 'read_only', create_page: 'approval_required' };
+  if (key === 'hubspot') return { list_contacts: 'read_only', search_contacts: 'read_only', create_contact: 'approval_required' };
+  return { inspect_status: 'read_only' };
+}
+
+function connectionFromStatus(id, connected, contractConnector = null) {
+  const key = canonicalConnectorId(id);
+  const authority = contractConnector && contractConnector.authority && typeof contractConnector.authority === 'object'
+    ? contractConnector.authority
+    : defaultAuthority(key);
+  return {
+    id: key,
+    name: connectorDisplayName(key),
+    connected: connected === true,
+    local: false,
+    actions: Object.keys(authority),
+    scopes: CONNECTOR_SCOPES[key] || [],
+    authority,
+    source: 'ax_integrations_status'
+  };
+}
+
+function statusConnected(statuses, id) {
+  const keys = [id, id.replace(/_/g, '-'), canonicalConnectorId(id)];
+  for (const key of keys) {
+    const value = statuses[key];
+    if (value === true) return true;
+    if (value && typeof value === 'object') {
+      if (value.connected === true) return true;
+      if (String(value.status || '').toLowerCase() === 'connected') return true;
+    }
+  }
+  return false;
+}
+
+async function buildConnectionContext(options = {}) {
+  const token = options.token || authToken();
+  const localStatusUserId = isLoopbackBackend() ? authUserId() : '';
+  const statusPath = localStatusUserId
+    ? `${ATRIS2_CONNECTION_STATUS_PATH}?connection_user_id=${encodeURIComponent(localStatusUserId)}`
+    : CONNECTION_STATUS_PATH;
+  const [statusRes, contractRes] = await Promise.all([
+    localStatusUserId || token ? requestJson(statusPath, { token: localStatusUserId ? '' : token }) : Promise.resolve({ ok: false, data: null }),
+    requestJson(CONNECTION_CAPABILITIES_PATH, { token: '' })
+  ]);
+  const statusData = statusRes.ok && statusRes.data && typeof statusRes.data === 'object' ? statusRes.data : {};
+  const statuses = statusData.statuses && typeof statusData.statuses === 'object' ? statusData.statuses : statusData;
+  const contractConnectors = new Map();
+  if (contractRes.ok && contractRes.data && Array.isArray(contractRes.data.connectors)) {
+    for (const connector of contractRes.data.connectors) {
+      const key = canonicalConnectorId(connector.id);
+      if (key) contractConnectors.set(key, connector);
+    }
+  }
+  const ids = new Set([
+    ...Object.keys(CONNECTOR_NAMES),
+    ...Object.keys(statuses).map(canonicalConnectorId),
+    ...contractConnectors.keys(),
+  ]);
+  const connections = [...ids].sort().map(id => connectionFromStatus(
+    id,
+    statusConnected(statuses, id),
+    contractConnectors.get(id)
+  ));
+  connections.push({
+    id: 'computer.local',
+    name: 'This Mac workspace',
+    connected: options.localWorkspace === true,
+    local: true,
+    status: options.localWorkspace === true ? 'available' : 'cloud_only',
+    actions: ['inspect_status', 'use_local_workspace'],
+    scopes: ['computer', 'workspace'],
+    authority: { inspect_status: 'read_only', use_local_workspace: 'read_only' },
+    source: 'ax'
+  });
+  return {
+    schema: 'atris.connection_capabilities.v1',
+    source: 'ax',
+    stale: false,
+    capability_contract_source: contractRes.ok ? 'backend' : 'fallback',
+    capability_contract_schema: contractRes.data && contractRes.data.schema,
+    capability_contract_connectors: contractConnectors.size || undefined,
+    connections
+  };
+}
+
+function mentionsConnector(message) {
+  return /\b(gmail|email|mail|inbox|calendar|events?|meetings?|schedule|google drive|drive|docs?|sheets?|github|slack|linear|notion|hubspot|integrations?|connectors?|connections?|connected apps?|connected tools?)\b/i.test(message || '');
+}
+
+function connectorWriteIntent(message) {
+  return mentionsConnector(message) && /\b(send|post|dm|message|reply|draft|compose|schedule|book|create|update|delete|archive|move|share|comment|invite)\b/i.test(message || '');
+}
+
+function workspaceIntent(message) {
+  return /\b(files?|folders?|repo|workspace|project|directory|tree|read|open|inspect|search|grep|find|locate|where|edit|write|change|modify|patch|fix|test|tests?|build|src|source|code|diff|git|backend|frontend|atris task|atris xp|xp game|career xp|agentxp|todo|map)\b/i.test(message || '');
+}
+
+function resolveRoute(message, options = {}) {
+  if (options.route === 'local' || options.forceLocal) return 'local';
+  if (options.route === 'cloud' || options.forceCloud) return 'cloud';
+  if (mentionsConnector(message) && !workspaceIntent(message)) return 'cloud';
+  return 'local';
+}
+
+function formatPrompt() {
+  return '› ';
+}
+
+function formatWorkingLine(ms) {
+  const totalSeconds = Math.max(1, Math.round((Number(ms) || 0) / 1000));
+  return `• Working (${formatSeconds(totalSeconds)} • ctrl-c to interrupt)`;
+}
+
+function formatDoneLine(ms) {
+  return `— Worked for ${formatDuration(ms)} —`;
+}
+
+function useColor(options = {}) {
+  if (options.color === false) return false;
+  if (process.env.NO_COLOR) return false;
+  return Boolean(options.color || options.isTTY);
+}
+
+function paint(text, codes, options = {}) {
+  if (!useColor(options)) return String(text);
+  return `${codes.join('')}${text}${ANSI.reset}`;
+}
+
+function truncateMiddle(value, limit = 120) {
+  const text = String(value || '');
+  if (text.length <= limit) return text;
+  const head = Math.max(8, Math.floor((limit - 3) * 0.6));
+  const tail = Math.max(8, limit - 3 - head);
+  return `${text.slice(0, head)}...${text.slice(-tail)}`;
+}
+
+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);
+  }
+
+  const slash = raw.lastIndexOf('/');
+  if (slash === -1) return paint(raw, [ANSI.bold, ANSI.accent], 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)}`;
+}
+
+function formatAuxRow(label, value, options = {}) {
+  const tag = String(label || '').padEnd(4);
+  const color = label === 'ok' ? [ANSI.ok] : [ANSI.muted];
+  return `  ${paint(tag, color, options)}  ${value}`;
+}
+
+function createProgressReporter(output, options = {}) {
+  const enabled = options.showProgress !== false;
+  const isTty = Boolean(output && output.isTTY);
+  const startedAt = Date.now();
+  let interval = null;
+  let timeout = null;
+  let shown = false;
+  let closed = false;
+
+  const render = () => {
+    if (!enabled || closed) return;
+    const line = formatWorkingLine(Date.now() - startedAt);
+    if (isTty) {
+      output.write(`\r${line}\x1b[K`);
+    } else if (!shown) {
+      output.write(`${line}\n`);
+    }
+    shown = true;
+  };
+
+  return {
+    start() {
+      if (!enabled) return;
+      timeout = setTimeout(() => {
+        render();
+        if (isTty) interval = setInterval(render, 1000);
+      }, 700);
+    },
+    clear() {
+      if (!isTty || !shown || closed) return;
+      output.write('\r\x1b[K');
+      shown = false;
+    },
+    stop() {
+      closed = true;
+      clearTimeout(timeout);
+      clearInterval(interval);
+      if (isTty && shown) output.write('\r\x1b[K');
+      shown = false;
+    }
+  };
+}
+
+function parseSseBlock(block) {
+  const data = String(block || '')
+    .split(/\r?\n/)
+    .filter(line => line.startsWith('data:'))
+    .map(line => line.replace(/^data:\s?/, ''))
+    .join('\n')
+    .trim();
+
+  if (!data || data === '[DONE]') return null;
+  return JSON.parse(data);
+}
+
+function summarizeToolInput(block) {
+  const options = arguments[1] || {};
+  const tool = block.tool || 'tool';
+  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.pattern || input.query) {
+    const pattern = truncateMiddle(input.pattern || input.query, 80);
+    return pathValue
+      ? `${toolName}  ${pattern}  in  ${formatPathSubject(pathValue, options)}`
+      : `${toolName}  ${pattern}`;
+  }
+  if (pathValue) return `${toolName}  ${formatPathSubject(pathValue, options)}`;
+  const subject = input.type || '';
+  return subject ? `${toolName}  ${String(subject).slice(0, 120)}` : toolName;
+}
+
+function summarizeToolResult(result) {
+  const options = arguments[1] || {};
+  const content = String(result.content || '');
+  if (!content) return 'done';
+
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.error) return `error: ${parsed.error}`;
+    if (Array.isArray(parsed.matches)) {
+      const where = parsed.path ? `  in  ${formatPathSubject(parsed.path, options)}` : '';
+      return `${parsed.matches.length} matches${where}`;
+    }
+    if (Array.isArray(parsed.files) || Array.isArray(parsed.dirs)) {
+      const parts = [];
+      if (Array.isArray(parsed.files)) parts.push(`${parsed.files.length} files`);
+      if (Array.isArray(parsed.dirs)) parts.push(`${parsed.dirs.length} dirs`);
+      const where = parsed.path ? `  in  ${formatPathSubject(parsed.path, options)}` : '';
+      return `${parts.join(' / ')}${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.
+  }
+
+  return content.length > 120 ? `${content.slice(0, 117)}...` : content;
+}
+
+function formatStatusMessage(message) {
+  const text = String(message || '').trim();
+  if (!text || text === 'complete') return null;
+  if (text === 'retrying_with_required_local_tool') return null;
+  return text.replace(/_/g, ' ');
+}
+
+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);
+  return parts.length ? parts.join('  ') : null;
+}
+
+function clearRetriedText(state) {
+  state.pendingText = '';
+  state.output = '';
+  state.wroteText = false;
+  state.lastChar = '\n';
+  state.inAuxBlock = false;
+}
+
+function stopProgress(state) {
+  if (!state.progress) return;
+  state.progress.stop();
+  state.progress = null;
+}
+
+function flushPendingText(state, output) {
+  if (!state.pendingText) return;
+  stopProgress(state);
+  if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
+  output.write(state.pendingText);
+  state.wroteText = true;
+  state.wroteActivity = true;
+  state.lastChar = state.pendingText.slice(-1);
+  state.pendingText = '';
+  state.inAuxBlock = false;
+}
+
+function writeStreamingText(state, output, content) {
+  if (!content) return;
+  stopProgress(state);
+  if (state.inAuxBlock && state.lastChar === '\n') output.write('\n');
+  output.write(content);
+  state.wroteText = true;
+  state.wroteActivity = true;
+  state.lastChar = String(content).slice(-1);
+  state.inAuxBlock = false;
+}
+
+function writeAuxLine(state, output, line) {
+  if (!line) return;
+  stopProgress(state);
+  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;
+}
+
+function compactHistory(history, limit = 8) {
+  return history
+    .slice(-limit)
+    .map(turn => `${turn.role}: ${String(turn.content || '').slice(0, 1200)}`)
+    .join('\n');
+}
+
+function buildMessage(message, history = []) {
+  const trimmed = String(message || '').trim();
+  if (!history.length) return trimmed;
+  return [
+    'Continue this terminal coding-agent conversation in the same workspace.',
+    'Use local tools when the user asks about files, code, tests, or edits.',
+    '',
+    'Recent conversation:',
+    compactHistory(history),
+    '',
+    `Current user message: ${trimmed}`,
+  ].join('\n');
+}
+
+function buildPayload(message, options = {}) {
+  const mode = options.mode === 'fast' ? 'fast' : 'pro';
+  const route = resolveRoute(message, options);
+  const local = route !== 'cloud';
+  const payload = {
+    message: buildMessage(message, options.history || []),
+    model: modelForMode(mode),
+    max_turns: local ? (mode === 'pro' ? 14 : 8) : 1,
+    verify_command: 'true'
+  };
+  if (local) {
+    payload.workspace_path = options.cwd || process.cwd();
+  }
+  if (options.connectionContext) {
+    payload.connection_context = options.connectionContext;
+  }
+  if (!local && options.connectionUserId) {
+    payload.connection_user_id = options.connectionUserId;
+  }
+  if (!local && connectorWriteIntent(message)) {
+    payload.allow_external_actions = true;
+    payload.cleanup_external_actions = true;
+    payload.max_turns = mode === 'pro' ? 4 : 2;
+  }
+  return payload;
+}
+
+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;
+  }
+
+  if ((event.type === 'text_delta' || event.type === 'text') && event.content) {
+    state.output += event.content;
+    if (output && output.isTTY) writeStreamingText(state, output, event.content);
+    else state.pendingText += event.content;
+    return;
+  }
+
+  if (event.type === 'assistant_blocks' && Array.isArray(event.blocks)) {
+    for (const block of event.blocks) {
+      if (block && block.type === 'tool_use') {
+        flushPendingText(state, output);
+        writeAuxLine(state, output, formatAuxRow('tool', summarizeToolInput(block, output), output));
+      }
+    }
+    return;
+  }
+
+  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));
+    }
+    return;
+  }
+
+  if (event.type === 'status' && event.message && event.message !== 'complete') {
+    if (event.message === 'retrying_with_required_local_tool') {
+      clearRetriedText(state);
+      return;
+    }
+    flushPendingText(state, output);
+    writeAuxLine(state, output, formatAuxRow('info', formatStatusMessage(event.message), output));
+    return;
+  }
+
+  if (event.type === 'error' || event.error) {
+    state.errors.push(event.error || event.message || 'Atris2 stream error');
+  }
+}
+
+async function postTurn(message, options = {}) {
+  const route = resolveRoute(message, options);
+  const local = route !== 'cloud';
+  const token = authToken();
+  const shouldSendConnectionContext = options.connectionContext
+    || route === 'cloud'
+    || mentionsConnector(message)
+    || /\b(can you use|can you access|connected|connections?|integrations?|tools?|capabilities)\b/i.test(message || '');
+  const connectionContext = options.connectionContext || (shouldSendConnectionContext
+    ? await buildConnectionContext({ token, localWorkspace: local })
+    : null);
+  const connectionUserId = !local && isLoopbackBackend() ? authUserId() : '';
+  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;
+  const turnUrl = new URL(backendUrl());
+  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
+  };
+
+  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: 'text/event-stream',
+        ...(token ? { Authorization: `Bearer ${token}` } : {})
+      }
+    }, (res) => {
+      res.setEncoding('utf8');
+      let buffer = '';
+      let rawBody = '';
+
+      res.on('data', (chunk) => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          rawBody += chunk;
+          return;
+        }
+
+        buffer += chunk;
+        let boundary = buffer.indexOf('\n\n');
+        while (boundary !== -1) {
+          const block = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          try {
+            handleEvent(parseSseBlock(block), state, output);
+          } catch (error) {
+            state.errors.push(`bad_sse_event: ${error.message}`);
+          }
+          boundary = buffer.indexOf('\n\n');
+        }
+      });
+
+      res.on('end', () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          try {
+            const parsed = JSON.parse(rawBody);
+            finish(new Error(parsed.detail || parsed.error || `HTTP ${res.statusCode}`));
+          } catch (_) {
+            finish(new Error(rawBody || `HTTP ${res.statusCode}`));
+          }
+          return;
+        }
+
+        if (buffer.trim()) {
+          try {
+            handleEvent(parseSseBlock(buffer), state, output);
+          } catch (error) {
+            state.errors.push(`bad_sse_event: ${error.message}`);
+          }
+        }
+
+        if (state.errors.length) {
+          finish(new Error(state.errors.join('; ')));
+          return;
+        }
+
+        flushPendingText(state, output);
+        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();
+  });
+}
+
+async function chat(options = {}) {
+  const mode = options.mode === 'fast' ? 'fast' : 'pro';
+  const cwd = options.cwd || process.cwd();
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const history = [];
+
+  output.write(`${formatHeader({ mode, cwd, chat: true })}\n\n`);
+
+  const runLine = async (line) => {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) return false;
+    if (EXIT_WORDS.has(trimmed.toLowerCase())) return true;
+
+    output.write('\n');
+    const result = await postTurn(trimmed, { mode, cwd, history, output });
+    if (result.output && !result.output.endsWith('\n')) output.write('\n');
+    output.write(`${formatDoneLine(result.durationMs)}\n\n`);
+    history.push({ role: 'user', content: trimmed });
+    history.push({ role: 'assistant', content: result.output || '' });
+    return false;
+  };
+
+  if (!input.isTTY) {
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (await runLine(line)) break;
+    }
+    return;
+  }
+
+  const rl = readline.createInterface({ input, output });
+  const ask = () => new Promise(resolve => rl.question(formatPrompt(mode), resolve));
+  while (true) {
+    const line = await ask();
+    if (await runLine(line)) {
+      rl.close();
+      break;
+    }
+  }
+}
+
+function printBackendHint() {
+  console.log('');
+  console.log('Start backend:');
+  console.log(`cd /Users/keshavrao/arena/atrisos-backend/backend && ATRIS2_ALLOW_LOCAL_WORKSPACE=1 ENVIRONMENT=development ENV=development ../venv/bin/uvicorn main:app --host ${BACKEND.host} --port ${BACKEND.port}`);
+}
+
+function bufferedOutput() {
+  let text = '';
+  return {
+    isTTY: false,
+    write(chunk) {
+      text += String(chunk || '');
+      return true;
+    },
+    text() {
+      return text;
+    }
+  };
+}
+
+function receiptFromState(state) {
+  const event = [...(state.events || [])].reverse().find(item => item && item.type === 'receipt' && item.receipt);
+  return event ? event.receipt : null;
+}
+
+function toolEventsFromState(state) {
+  const receipt = receiptFromState(state);
+  if (receipt && Array.isArray(receipt.tool_events)) return receipt.tool_events;
+  return [];
+}
+
+function assertBenchmark(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function toolEventText(events) {
+  return JSON.stringify(events || []);
+}
+
+async function runBenchmarkCase(label, fn, results, output) {
+  const startedAt = Date.now();
+  output.write(`- ${label} ... `);
+  try {
+    const detail = await fn();
+    const duration = formatDuration(Date.now() - startedAt);
+    output.write(`ok (${duration})${detail ? ` - ${detail}` : ''}\n`);
+    results.push({ label, ok: true, duration_ms: Date.now() - startedAt, detail });
+  } catch (error) {
+    const duration = formatDuration(Date.now() - startedAt);
+    output.write(`fail (${duration}) - ${error.message}\n`);
+    results.push({ label, ok: false, duration_ms: Date.now() - startedAt, error: error.message });
+  }
+}
+
+async function runBenchmark(options = {}) {
+  const mode = options.mode === 'pro' ? 'pro' : 'fast';
+  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(`${backendUrl()}\n\n`);
+
+  try {
+    await runBenchmarkCase('search through files', async () => {
+      const workspace = path.join(tempRoot, 'search');
+      fs.mkdirSync(path.join(workspace, 'src', 'deep'), { recursive: true });
+      fs.writeFileSync(path.join(workspace, 'package.json'), '{"name":"ax-search-bench"}\n');
+      fs.writeFileSync(path.join(workspace, 'src', 'deep', 'needle.txt'), 'AX_SEARCH_SENTINEL=found-here\n');
+      const sink = localOut();
+      const state = await postTurn(
+        'Use local tools to search for AX_SEARCH_SENTINEL and answer with the exact file path. Do not edit.',
+        { mode, cwd: workspace, route: 'local', output: sink, showProgress: false }
+      );
+      const combined = `${state.output}\n${toolEventText(toolEventsFromState(state))}`;
+      assertBenchmark(/src\/deep\/needle\.txt/.test(combined), 'missing proof path src/deep/needle.txt');
+      assertBenchmark(/AX_SEARCH_SENTINEL/.test(combined), 'missing sentinel proof');
+      return 'found src/deep/needle.txt';
+    }, results, output);
+
+    await runBenchmarkCase('modify files', async () => {
+      const workspace = path.join(tempRoot, 'edit');
+      fs.mkdirSync(path.join(workspace, 'src'), { recursive: true });
+      fs.writeFileSync(path.join(workspace, 'package.json'), '{"name":"ax-edit-bench"}\n');
+      const target = path.join(workspace, 'src', 'bench-target.txt');
+      fs.writeFileSync(target, 'status=AX_BEFORE\n');
+      const sink = localOut();
+      const state = await postTurn(
+        'Use local tools to edit src/bench-target.txt. Replace AX_BEFORE with AX_AFTER, then report the changed file. Do not create any other files.',
+        { mode, cwd: workspace, route: 'local', output: sink, showProgress: false }
+      );
+      const text = fs.readFileSync(target, 'utf8');
+      assertBenchmark(text.includes('AX_AFTER'), 'src/bench-target.txt was not modified');
+      const combined = `${state.output}\n${toolEventText(toolEventsFromState(state))}`;
+      assertBenchmark(/bench-target\.txt/.test(combined), 'missing changed-file proof in response or receipt');
+      return 'edited src/bench-target.txt';
+    }, results, output);
+
+    await runBenchmarkCase('use Atris workspace state', async () => {
+      const cwd = options.cwd || process.cwd();
+      assertBenchmark(fs.existsSync(path.join(cwd, 'atris')), 'current workspace has no atris/ directory');
+      const sink = localOut();
+      const state = await postTurn(
+        'Use Atris local tools to inspect current task or map state. Report one concrete Atris file or task source you used. Do not edit files.',
+        { mode, cwd, route: 'local', output: sink, showProgress: false }
+      );
+      const combined = `${state.output}\n${toolEventText(toolEventsFromState(state))}`;
+      assertBenchmark(/atris\/(TODO|MAP|atris)\.md|local_task_op|local_map_op|Task|Map/.test(combined), 'missing Atris task/map proof');
+      return 'read Atris task/map surface';
+    }, results, output);
+
+    await runBenchmarkCase('know XP system', async () => {
+      const cwd = options.cwd || process.cwd();
+      assertBenchmark(fs.existsSync(path.join(cwd, 'atris')), 'current workspace has no atris/ directory');
+      const sink = localOut();
+      const state = await postTurn(
+        'Use the local RewardRubric/Atris tools or workspace files to explain the Career XP reward system in this workspace. Mention proof, review/acceptance, and reward/XP. Cite the exact tool or file you used. Do not edit files.',
+        { mode, cwd, route: 'local', output: sink, showProgress: false }
+      );
+      const combined = `${state.output}\n${toolEventText(toolEventsFromState(state))}`;
+      assertBenchmark(/xp|reward|rubric/i.test(combined), 'missing XP/reward/rubric proof');
+      assertBenchmark(/proof|review|accept|approval/i.test(combined), 'missing proof/review/acceptance explanation');
+      assertBenchmark(/RewardRubric|local_reward_rubric_op|atris\/|main\.js|taskBoard/i.test(combined), 'missing cited XP source or tool');
+      return 'explained XP reward loop';
+    }, results, output);
+
+    await runBenchmarkCase('list connections', async () => {
+      const context = await buildConnectionContext({ token: authToken(), localWorkspace: false });
+      const connected = (context.connections || []).filter(row => row.connected);
+      assertBenchmark((context.connections || []).length >= 5, 'connection capability context is missing');
+      const sink = localOut();
+      const state = await postTurn(
+        'Which Atris integrations are connected for me? Include Google Calendar status. Answer from live connection context.',
+        { mode, route: 'cloud', output: sink, showProgress: false, connectionContext: context }
+      );
+      const receipt = receiptFromState(state);
+      assertBenchmark(receipt && receipt.connection_context, 'receipt missing connection_context');
+      const answer = `${state.output}\n${receipt && receipt.final ? receipt.final : ''}`;
+      assertBenchmark(/calendar|gmail|github|slack|drive|integration|connected/i.test(answer), 'answer did not discuss integrations');
+      return `${connected.length} connected reported`;
+    }, results, output);
+
+    await runBenchmarkCase('read calendar', async () => {
+      const sink = localOut();
+      const state = await postTurn(
+        'What is on my calendar today? Use the connected Google Calendar read path and be concise.',
+        { mode, route: 'cloud', output: sink, showProgress: false }
+      );
+      const events = toolEventsFromState(state);
+      const text = toolEventText(events);
+      assertBenchmark(/google_calendar/.test(text), 'calendar tool event missing');
+      assertBenchmark(!/"status":"not_connected"/.test(text), 'Google Calendar is not connected for this account');
+      assertBenchmark(/Calendar|event|No calendar events|meeting/i.test(state.output), 'calendar answer missing');
+      return 'calendar read path responded';
+    }, results, output);
+  } finally {
+    try {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    } catch (_) {}
+  }
+
+  const failed = results.filter(result => !result.ok);
+  output.write('\n');
+  output.write(failed.length ? `Benchmark failed: ${failed.length}/${results.length} failed\n` : `Benchmark passed: ${results.length}/${results.length}\n`);
+  if (failed.length) {
+    const error = new Error(failed.map(result => `${result.label}: ${result.error}`).join('; '));
+    error.results = results;
+    throw error;
+  }
+  return results;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(formatUsage());
+    return;
+  }
+
+  const mode = 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))
+    .join(' ')
+    .trim();
+
+  try {
+    if (benchmark) {
+      await runBenchmark({ mode, cwd: process.cwd(), output: process.stdout });
+      return;
+    }
+
+    if (doctor) {
+      console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }));
+      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 });
+      return;
+    }
+
+    console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }));
+    console.log('');
+    const result = await postTurn(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route });
+    console.log('');
+    console.log(formatDoneLine(result.durationMs));
+  } catch (error) {
+    console.error(`x ${error.message}`);
+    printBackendHint();
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  authToken,
+  authUserId,
+  backendBaseUrl,
+  backendUrl,
+  buildPayload,
+  buildConnectionContext,
+  buildRunProfile,
+  chat,
+  createProgressReporter,
+  formatDoneLine,
+  formatDuration,
+  formatHeader,
+  formatPathSubject,
+  formatPrompt,
+  formatRunProfile,
+  formatStatusMessage,
+  formatSystemInit,
+  formatUsage,
+  formatWorkingLine,
+  handleEvent,
+  modelForMode,
+  parseSseBlock,
+  postTurn,
+  resolveRoute,
+  runBenchmark,
+  summarizeToolInput,
+  summarizeToolResult
+};