atris 3.30.8 → 3.31.0

package/ax

@@ -9,6 +9,7 @@ const readline = require('readline');
 const crypto = require('crypto');
 const { Readable } = require('stream');
 const { loadCredentials } = require('./utils/auth');
+const missionRuntime = require('./lib/mission-runtime-loop');
 
 const EXIT_WORDS = new Set(['exit', 'quit', ':q']);
 const BACKEND = {
@@ -16,8 +17,8 @@ const BACKEND = {
   port: 8000,
   path: '/api/atris2/turn'
 };
-const DEFAULT_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
 const CLOUD_BACKEND_BASE = 'https://api.atris.ai';
+const LOCAL_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
 const CODE_FAST = {
   path: '/api/cursor/turn',
   model: 'composer-2-5-fast',
@@ -125,11 +126,11 @@ function formatUsage() {
     '  ax [--max|--fast] --benchmark',
     '',
     'Modes:',
-    '  --max   highest reasoning, slowest turns',
-    '  --pro   deeper tool loop',
-    '  --fast  faster low-latency turns',
+    '  --max   hosted Atris 2, highest reasoning, slowest turns',
+    '  --pro   hosted Atris 2, deeper tool loop',
+    '  --fast  hosted Atris 2, faster low-latency turns',
     '  --code-fast  Atris Code Fast public lane',
-    '  --local force local workspace tools with your own AtrisOS backend',
+    '  --local opt into local backend/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)',
@@ -211,11 +212,12 @@ function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', out
 }
 
 function backendBaseUrl(options = {}) {
-  const explicitBase = process.env.AX_BACKEND_URL
-    || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL
-    || process.env.OBELISK_ATRIS2_BACKEND_URL;
-  if (explicitBase) return explicitBase.replace(/\/$/, '');
-  return options.route === 'cloud' ? CLOUD_BACKEND_BASE : DEFAULT_BACKEND_BASE;
+  const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
+  if (process.env.AX_BACKEND_URL) return process.env.AX_BACKEND_URL.replace(/\/$/, '');
+  if (route === 'local') {
+    return (process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL || LOCAL_BACKEND_BASE).replace(/\/$/, '');
+  }
+  return (process.env.OBELISK_ATRIS2_BACKEND_URL || process.env.ATRIS_API_BASE || CLOUD_BACKEND_BASE).replace(/\/$/, '');
 }
 
 function backendUrl(options = {}) {
@@ -268,9 +270,13 @@ function buildRunProfile(options = {}) {
       reasoning: 'Composer 2.5 fast lane; charges 10 credits per public turn'
     };
   }
-  const profileMessage = options.message || 'what files are here?';
-  const route = resolveRoute(profileMessage, options);
-  const payload = buildPayload(profileMessage, { mode, cwd, route });
+  const route = resolveRoute(options.message || 'doctor', options);
+  const payload = buildPayload(options.message || 'doctor', { mode, cwd, route });
+  const reasoningByMode = mode === 'max'
+    ? 'Max workspace tool loop uses high reasoning effort'
+    : mode === 'pro'
+      ? 'Pro workspace tool loop uses API default medium'
+      : 'Fast workspace tool loop uses provider default';
   return {
     endpoint: backendUrl({ route }),
     mode,
@@ -278,13 +284,11 @@ function buildRunProfile(options = {}) {
     model: payload.model,
     workspace_path: payload.workspace_path || 'cloud',
     max_turns: payload.max_turns,
+    member_slug: 'ax',
+    bypass_permissions: false,
     streaming: true,
     runtime: route === 'cloud' ? 'authenticated cloud connectors/chat' : 'local workspace',
-    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'
+    reasoning: `${route === 'cloud' ? 'Atris cloud service' : 'local backend'}; ${reasoningByMode}`
   };
 }
 
@@ -303,18 +307,23 @@ function formatRunProfile(profile, options = {}) {
 }
 
 async function buildRuntimeHealth(options = {}) {
+  const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
   const healthRes = options.healthRes
     ? await Promise.resolve(options.healthRes)
-    : await requestJson(ATRIS2_HEALTH_PATH, { token: '', timeoutMs: options.timeoutMs || 1500, route: options.route || 'local' });
+    : await requestJson(ATRIS2_HEALTH_PATH, { token: route === 'cloud' ? authToken() : '', timeoutMs: options.timeoutMs || 1500, route });
   const data = healthRes.ok && healthRes.data && typeof healthRes.data === 'object' ? healthRes.data : {};
   const models = Array.isArray(data.models) ? data.models : [];
   const fast = models.find(row => row && row.id === 'atris:fast') || null;
+  const status = Number(healthRes.status || 0);
+  const authRequired = status === 401 || status === 403;
   return {
     schema: 'ax.runtime_health.v1',
+    route,
     backend: {
       ready: Boolean(healthRes.ok && data.ready),
-      reachable: Boolean(healthRes.ok),
-      status: healthRes.status || 0,
+      reachable: Boolean(healthRes.ok || status > 0),
+      auth_required: authRequired,
+      status,
       error: healthRes.error || '',
     },
     fast: {
@@ -331,14 +340,19 @@ async function buildRuntimeHealth(options = {}) {
 function formatRuntimeHealth(health, options = {}) {
   const backendReady = health && health.backend && health.backend.ready;
   const backendReachable = health && health.backend && health.backend.reachable;
+  const authRequired = health && health.backend && health.backend.auth_required;
   const fastReady = health && health.fast && health.fast.ready;
   const permissionReady = health && health.permissions && health.permissions.ready;
   const rows = [
-    ['backend', backendReady ? 'ready' : backendReachable ? 'not ready' : 'offline'],
+    ['backend', authRequired ? 'auth required' : backendReady ? 'ready' : backendReachable ? 'not ready' : 'offline'],
     ['fast', fastReady ? 'ready' : 'not ready'],
-    ['approvals', permissionReady ? 'ready' : 'offline'],
+    ['approvals', authRequired ? 'auth required' : permissionReady ? 'ready' : 'offline'],
   ];
-  if (!backendReachable) rows.push(['fix', 'local backend offline; use hosted mode or start your AtrisOS backend']);
+  if (authRequired) {
+    rows.push(['fix', 'run atris login, then rerun ax --doctor']);
+  } else if (!backendReachable) {
+    rows.push(['fix', health?.route === 'local' ? 'start local backend, then rerun ax --doctor' : 'Atris cloud unavailable; retry or run ax --doctor']);
+  }
   return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
 }
 
@@ -527,7 +541,7 @@ function cachedIntegrationStatus(options = {}) {
 
 async function buildConnectionContext(options = {}) {
   const token = options.token || authToken();
-  const localStatusUserId = isLoopbackBackend({ route: options.route }) ? authUserId() : '';
+  const localStatusUserId = isLoopbackBackend() ? authUserId() : '';
   const statusPath = localStatusUserId
     ? `${ATRIS2_CONNECTION_STATUS_PATH}?connection_user_id=${encodeURIComponent(localStatusUserId)}`
     : CONNECTION_STATUS_PATH;
@@ -535,9 +549,9 @@ async function buildConnectionContext(options = {}) {
     options.statusRes
       ? Promise.resolve(options.statusRes)
       : localStatusUserId || token
-        ? requestJson(statusPath, { token: localStatusUserId ? '' : token, route: options.route })
+        ? requestJson(statusPath, { token: localStatusUserId ? '' : token })
         : Promise.resolve({ ok: false, data: null }),
-    options.contractRes ? Promise.resolve(options.contractRes) : requestJson(CONNECTION_CAPABILITIES_PATH, { token: '', route: options.route })
+    options.contractRes ? Promise.resolve(options.contractRes) : requestJson(CONNECTION_CAPABILITIES_PATH, { token: '' })
   ]);
   const statusData = statusRes.ok && statusRes.data && typeof statusRes.data === 'object' ? statusRes.data : {};
   const backendStatuses = statusData.statuses && typeof statusData.statuses === 'object' ? statusData.statuses : statusData;
@@ -598,15 +612,7 @@ function connectorWriteIntent(message) {
 }
 
 function workspaceIntent(message) {
-  return Boolean(workspaceIntentReason(message));
-}
-
-function workspaceIntentReason(message) {
-  const text = String(message || '');
-  if (/\b(files?|folders?|repo|workspace|project|directory|tree|src|source|code|diff|git|backend|frontend|atris task|atris xp|xp game|career xp|agentxp|todo|map|tests?)\b/i.test(text)) return 'prompt mentions workspace, file, code, or repo terms';
-  if (/(^|\s|["'`])(?:\.{0,2}\/)?[\w.-]+\/[\w./-]+|[\w.-]+\.(?:js|jsx|ts|tsx|mjs|cjs|json|md|py|rb|go|rs|java|css|scss|html|yml|yaml|toml|env|txt)\b/i.test(text)) return 'prompt names a file path or filename';
-  if (/\b(read|open|inspect|search|grep|find|locate|where|edit|write|change|modify|patch|fix|test|build|refactor)\b.*\b(this|file|folder|repo|workspace|project|directory|module|component|package|readme|source|code|branch|suite|build|bug)\b/i.test(text)) return 'prompt asks to operate on workspace material';
-  return '';
+  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 githubWorkspaceIntent(message) {
@@ -616,22 +622,9 @@ function githubWorkspaceIntent(message) {
 }
 
 function resolveRoute(message, options = {}) {
-  return routeDecision(message, options).route;
-}
-
-function routeDecision(message, options = {}) {
-  if (options.route === 'local' || options.forceLocal) return { route: 'local', reason: 'explicit --local' };
-  if (options.route === 'cloud' || options.forceCloud) return { route: 'cloud', reason: 'explicit --cloud' };
-  if (githubWorkspaceIntent(message)) return { route: 'local', reason: 'prompt asks for GitHub repo mutation' };
-  const reason = workspaceIntentReason(message);
-  if (mentionsConnector(message) && !reason) return { route: 'cloud', reason: 'connector request uses hosted Atris' };
-  if (reason) return { route: 'local', reason };
-  return { route: 'cloud', reason: 'default hosted chat' };
-}
-
-function shouldPreflightRuntime(route, options = {}, mode = 'fast') {
-  if (options.skipRuntimePreflight || options.turnFunction || options.business || normalizeMode(mode) === 'code-fast') return false;
-  return route !== 'cloud';
+  if (options.route === 'local' || options.forceLocal) return 'local';
+  if (options.route === 'cloud' || options.forceCloud) return 'cloud';
+  return 'cloud';
 }
 
 function normalizeMode(mode) {
@@ -705,6 +698,161 @@ function formatDoneLine(ms, credits) {
   return `${base} —`;
 }
 
+function stripMissionQuotes(value) {
+  const text = String(value || '').trim();
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      return text.slice(1, -1).trim();
+    }
+  }
+  return text;
+}
+
+function extractMissionFlag(text, flagName) {
+  const source = String(text || '');
+  const inline = new RegExp(`(^|\\s)${flagName}=([^\\s]+)(?=\\s|$)`).exec(source);
+  if (inline) {
+    return {
+      value: inline[2],
+      text: `${source.slice(0, inline.index)}${inline[1] || ''}${source.slice(inline.index + inline[0].length)}`.replace(/\s+/g, ' ').trim(),
+    };
+  }
+  const split = new RegExp(`(^|\\s)${flagName}\\s+([^\\s]+)(?=\\s|$)`).exec(source);
+  if (split) {
+    return {
+      value: split[2],
+      text: `${source.slice(0, split.index)}${split[1] || ''}${source.slice(split.index + split[0].length)}`.replace(/\s+/g, ' ').trim(),
+    };
+  }
+  return { value: null, text: source.trim() };
+}
+
+function missionRunIntentFromMessage(message) {
+  return missionRuntime.missionRunIntentFromMessage(message);
+}
+
+function loadMissionRecord(cwd, missionId) {
+  if (!missionId) return null;
+  try {
+    const statePath = path.join(cwd || process.cwd(), '.atris', 'state', 'missions.jsonl');
+    if (!fs.existsSync(statePath)) return null;
+    const lines = fs.readFileSync(statePath, 'utf8').split('\n').filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      let record;
+      try {
+        record = JSON.parse(lines[i]);
+      } catch (_) {
+        continue;
+      }
+      const id = record && (record.id || record.mission_id);
+      if (id === missionId) return record;
+    }
+  } catch (_) {
+    return null;
+  }
+  return null;
+}
+
+function currentAtrisGoal(cwd = process.cwd()) {
+  try {
+    const statePath = path.join(cwd, '.atris', 'state', 'atris_goal.json');
+    if (!fs.existsSync(statePath)) return null;
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    const goal = state && state.goal;
+    if (!goal || !goal.objective) return null;
+    if (String(goal.runner || '').trim().toLowerCase() === 'codex_goal') return null;
+    const mission = loadMissionRecord(cwd, goal.mission_id);
+    return {
+      ...goal,
+      mission_status: mission?.status || goal.mission_status,
+      created_at: goal.created_at || mission?.created_at || null,
+      updated_at: goal.updated_at || mission?.updated_at || null,
+      completed_at: goal.completed_at || mission?.completed_at || null,
+      next_command: goal.next_command || mission?.next_action || null,
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+function goalElapsedSeconds(goal) {
+  const started = Date.parse(goal?.created_at || '');
+  if (!Number.isFinite(started)) return null;
+  const ended = Date.parse(goal?.completed_at || '') || Date.now();
+  return Math.max(0, Math.floor((ended - started) / 1000));
+}
+
+function goalAchieved(goal) {
+  return ['complete', 'completed', 'achieved'].includes(String(goal?.mission_status || goal?.status || '').toLowerCase());
+}
+
+function formatAtrisGoal(goal) {
+  if (!goal) return '';
+  const objective = String(goal.objective || '').length > 92
+    ? `${String(goal.objective).slice(0, 89)}...`
+    : String(goal.objective || '');
+  const elapsed = goalElapsedSeconds(goal);
+  const missionParts = [
+    goal.mission_id || '?',
+    goal.mission_status || '?',
+    goal.runner || 'mission',
+  ];
+  if (elapsed !== null) missionParts.push(`elapsed ${formatSeconds(elapsed)}`);
+  missionParts.push(`achieved ${goalAchieved(goal) ? 'yes' : 'no'}`);
+  return [
+    `Atris goal: ${objective}`,
+    `Mission: ${missionParts.join(' · ')}`,
+    goal.next_command ? `Next: ${goal.next_command}` : '',
+  ].filter(Boolean).join('\n');
+}
+
+function writeAtrisGoalBanner(output, cwd = process.cwd()) {
+  const text = formatAtrisGoal(currentAtrisGoal(cwd));
+  if (!text) return false;
+  output.write(`${text}\n\n`);
+  return true;
+}
+
+function maybeWriteAtrisGoalBanner(output, cwd = process.cwd()) {
+  if (process.env.AX_SHOW_GOAL_BANNER !== '1') return false;
+  return writeAtrisGoalBanner(output, cwd);
+}
+
+function formatMissionStartReceipt(payload) {
+  const mission = payload?.mission || {};
+  const goal = payload?.atris_goal_state?.goal || {};
+  const receiptGoal = {
+    ...goal,
+    objective: goal.objective || mission.objective,
+    mission_id: goal.mission_id || mission.id,
+    mission_status: goal.mission_status || mission.status,
+    runner: goal.runner || mission.runner,
+    created_at: goal.created_at || mission.created_at,
+    updated_at: goal.updated_at || mission.updated_at,
+    completed_at: goal.completed_at || mission.completed_at,
+    next_command: goal.next_command || payload?.next_command || mission.next_action,
+  };
+  const elapsed = goalElapsedSeconds(receiptGoal);
+  return [
+    'Atris mission started',
+    `Goal: ${receiptGoal.objective || '?'}`,
+    `Mission: ${receiptGoal.mission_id || '?'} · ${receiptGoal.mission_status || '?'} · ${receiptGoal.runner || 'atris2'}`,
+    `Elapsed: ${elapsed === null ? '0s' : formatSeconds(elapsed)}`,
+    `Achieved: ${goalAchieved(receiptGoal) ? 'yes' : 'no'}`,
+    receiptGoal.next_command ? `Next: ${receiptGoal.next_command}` : '',
+  ].filter(Boolean).join('\n');
+}
+
+async function runLocalMission(intent, options = {}) {
+  return missionRuntime.runRuntimeMissionLoop(intent, {
+    cwd: options.cwd || process.cwd(),
+    cliPath: path.join(__dirname, 'bin', 'atris.js'),
+    onProgress: options.onProgress,
+  });
+}
+
 function useColor(options = {}) {
   if (options.color === false) return false;
   if (process.env.NO_COLOR) return false;
@@ -1017,6 +1165,51 @@ function formatApprovalTime(value) {
   return `${months[Number(month) - 1] || month} ${Number(day)}, ${year} at ${hour12}:${minute} ${ampm}`;
 }
 
+function previewText(value, limit = 80) {
+  return String(value || '').replace(/\s+/g, ' ').trim().slice(0, limit);
+}
+
+function previewContact(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return previewText(value, 120);
+  if (typeof value !== 'object') return previewText(value, 120);
+  return previewText(value.email || value.address || value.value || value.name || '', 120);
+}
+
+function previewContacts(value) {
+  const values = Array.isArray(value)
+    ? value
+    : String(value || '').includes(',')
+      ? String(value).split(',')
+      : [value];
+  return values
+    .map(previewContact)
+    .filter(Boolean)
+    .slice(0, 3)
+    .join(', ');
+}
+
+function gmailApprovalDetails(receipt, request, approvalEvent = null) {
+  const payload = request && request.payload && typeof request.payload === 'object' ? request.payload : {};
+  const taskPreview = receipt && receipt.task_preview && typeof receipt.task_preview === 'object' ? receipt.task_preview : {};
+  const slots = taskPreview.slots && typeof taskPreview.slots === 'object' ? taskPreview.slots : {};
+  const preview = approvalEvent && approvalEvent.preview && typeof approvalEvent.preview === 'object' ? approvalEvent.preview : {};
+  return {
+    to: previewContacts(payload.to || payload.recipient || payload.recipients || payload.email || slots.to || slots.recipient || preview.to),
+    subject: previewText(payload.subject || payload.title || slots.subject || preview.subject, 80),
+  };
+}
+
+function isGmailApproval(request, approvalEvent = null, accept = {}) {
+  const connector = canonicalConnectorId((request && request.connector) || (approvalEvent && approvalEvent.tool));
+  const action = String(
+    (request && (request.executor_action_type || request.action_type || request.action))
+    || accept.task
+    || ''
+  ).toLowerCase().replace(/_/g, ' ');
+  return connector === 'gmail' && /\b(send|reply|compose)\b/.test(action);
+}
+
 function formatApprovalReceipt(receipt) {
   if (!receipt || typeof receipt !== 'object') return null;
   const events = Array.isArray(receipt.tool_events) ? receipt.tool_events : [];
@@ -1034,6 +1227,15 @@ function formatApprovalReceipt(receipt) {
     return `Approval needed before creation: calendar event "${String(title).slice(0, 80)}"${when ? ` ${when}` : ''}`;
   }
 
+  if (isGmailApproval(request, approvalEvent, accept)) {
+    const details = gmailApprovalDetails(receipt, request, approvalEvent);
+    const parts = [
+      details.to ? `to ${details.to}` : '',
+      details.subject ? `subject "${details.subject}"` : '',
+    ].filter(Boolean);
+    return `Approval needed before sending Gmail${parts.length ? `: ${parts.join(' ')}` : ''} (body hidden until approved)`;
+  }
+
   const connector = String(request.connector || approvalEvent.tool || 'connector').replace(/_/g, ' ');
   const action = String(request.action || actionType || 'action').replace(/_/g, ' ');
   return `Approval needed before ${action}: ${connector}`;
@@ -1062,6 +1264,16 @@ function formatTaskPreviewPlan(receipt) {
   if (!taskPreview) return null;
   const task = String(taskPreview.task || '').trim();
   const slots = taskPreview.slots && typeof taskPreview.slots === 'object' ? taskPreview.slots : {};
+  const approvalEvent = taskPreviewApprovalEvent(receipt);
+  const request = approvalEvent && approvalEvent.approval_request;
+  if (isGmailApproval(request, approvalEvent, receipt.task_accept_receipt || {}) || task === 'gmail.send_message') {
+    const details = gmailApprovalDetails(receipt, request || { payload: slots }, approvalEvent);
+    return [
+      'send Gmail',
+      details.to ? `to ${details.to}` : '',
+      details.subject ? `subject "${details.subject}"` : '',
+    ].filter(Boolean).join(' ');
+  }
   if (task === 'calendar.create_event') {
     const title = taskPreviewTitle(receipt);
     const start = slots.start || (receipt.task_accept_receipt && receipt.task_accept_receipt.start);
@@ -1345,11 +1557,11 @@ function creditsFromApprovalExecution(response) {
   return Number.isFinite(credits) && credits > 0 ? credits : null;
 }
 
-async function postApprovalExecution(approvalRequest, { model = 'atris:fast', token = authToken(), route = 'cloud' } = {}) {
+async function postApprovalExecution(approvalRequest, { model = 'atris:fast', token = authToken() } = {}) {
   return postJson(APPROVAL_EXECUTE_PATH, {
     model,
     approval_request: approvalRequest,
-  }, { token, route });
+  }, { token });
 }
 
 async function executeApprovalRequest(approvalRequest, {
@@ -1564,12 +1776,30 @@ function buildMessage(message, history = []) {
   return String(message || '').trim();
 }
 
+function createTurnId() {
+  return `axt_${Date.now().toString(36)}_${crypto.randomBytes(4).toString('hex')}`;
+}
+
+function connectorTurnPolicy(message, options = {}) {
+  if (!connectorWriteIntent(message)) return null;
+  const policy = {
+    schema: 'ax.connector_turn.v1',
+    scope: 'current_turn_only',
+    policy: 'preview_then_explicit_approval',
+    writes_require_approval: true,
+  };
+  if (options.turnId) policy.turn_id = String(options.turnId);
+  if (options.conversationId) policy.conversation_id = String(options.conversationId);
+  return policy;
+}
+
 function buildPayload(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 previousMessages = structuredHistory(options.history || []);
+  const turnId = String(options.turnId || '').trim();
   const payload = {
     message: buildMessage(message, options.history || []),
     model: modelForMode(mode),
@@ -1582,6 +1812,14 @@ function buildPayload(message, options = {}) {
   if (options.conversationId) {
     payload.conversation_id = String(options.conversationId);
   }
+  if (turnId) {
+    payload.turn_id = turnId;
+  }
+  const connectorPolicy = !local ? connectorTurnPolicy(message, { ...options, turnId }) : null;
+  if (connectorPolicy) {
+    payload.connector_turn = connectorPolicy;
+    payload.external_action_policy = 'preview_then_explicit_approval';
+  }
   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
@@ -1732,23 +1970,25 @@ function handleEvent(event, state, output) {
 async function postTurn(message, options = {}) {
   const route = options.business ? 'local' : resolveRoute(message, options);
   const local = route !== 'cloud';
+  const endpointRoute = options.business ? 'cloud' : route;
   const token = authToken();
+  const turnId = options.turnId || createTurnId();
   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, route })
+    ? await buildConnectionContext({ token, localWorkspace: local })
     : null);
-  const connectionUserId = !local && isLoopbackBackend({ route }) ? authUserId() : '';
-  const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId });
+  const connectionUserId = !local && isLoopbackBackend({ route: endpointRoute }) ? authUserId() : '';
+  const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId, turnId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
   // 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({ route }));
+  const turnUrl = new URL(backendUrl({ route: endpointRoute }));
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
     events: [],
@@ -1769,7 +2009,7 @@ async function postTurn(message, options = {}) {
     relay: options.business ? {
       chain: Promise.resolve(),
       execute: options.business.executor,
-      post: (callId, result) => options.business.postToolResult(callId, result, backendBaseUrl())
+      post: (callId, result) => options.business.postToolResult(callId, result, backendBaseUrl({ route: 'cloud' }))
     } : null
   };
 
@@ -1989,23 +2229,27 @@ async function chat(options = {}) {
 
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
   if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
-
-  const runtimePreflight = { localReady: false };
-  const ensureRuntimeReady = async (routeForTurn = 'local', decision = {}) => {
-    if (!shouldPreflightRuntime(routeForTurn, options, mode)) {
+  maybeWriteAtrisGoalBanner(output, cwd);
+
+  const runtimePreflight = new Set();
+  const ensureRuntimeReady = async (routeForTurn = 'cloud') => {
+    const endpointRoute = routeForTurn === 'local' ? 'local' : 'cloud';
+    const key = `${normalizeMode(mode)}:${endpointRoute}`;
+    if (runtimePreflight.has(key)) return true;
+    if (options.skipRuntimePreflight || options.turnFunction || options.business || normalizeMode(mode) === 'code-fast') {
+      runtimePreflight.add(key);
       return true;
     }
-    if (runtimePreflight.localReady) return true;
     const startedAt = Date.now();
     const health = options.runtimeHealth
-      ? await Promise.resolve(options.runtimeHealth({ mode }))
-      : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200, route: 'local' });
+      ? await Promise.resolve(options.runtimeHealth({ mode, route: endpointRoute }))
+      : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200, route: endpointRoute });
     if (runtimeReadyForChat(health, mode)) {
-      runtimePreflight.localReady = true;
+      runtimePreflight.add(key);
       return true;
     }
     output.write(`${formatRuntimeHealth(health, output)}\n\n`);
-    output.write(`${formatBackendHint({ routeReason: decision.reason, explicitLocal: decision.reason === 'explicit --local' })}\n`);
+    output.write(`${formatBackendHint({ route: endpointRoute })}\n`);
     output.write(`${formatDoneLine(Date.now() - startedAt)}\n\n`);
     return false;
   };
@@ -2035,6 +2279,26 @@ async function chat(options = {}) {
 
     if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
     output.write('\n');
+
+    const missionIntent = missionRunIntentFromMessage(trimmed);
+    if (missionIntent) {
+      const result = await runLocalMission(missionIntent, {
+        cwd,
+        onProgress: (line) => {
+          if (/^pursuing /.test(line)) output.write('Pursuing goal...\n');
+          else if (/^still_running /.test(line)) {
+            const seconds = Number(String(line).split(/\s+/)[1]);
+            output.write(`Still pursuing... ${formatSeconds(seconds)}\n`);
+          } else if (/^landing /.test(line)) output.write('Landing goal...\n');
+          else if (/^\[tick /.test(line)) output.write(`${line}\n`);
+        },
+      });
+      output.write(`${result.text || 'Mission command failed.'}\n\n`);
+      history.push({ role: 'user', content: trimmed });
+      history.push({ role: 'assistant', content: result.text || 'Mission command failed.' });
+      return false;
+    }
+
     const pendingApprovalRequest = latestPendingApprovalRequest(history);
     if (pendingApprovalRequest && normalizeMode(mode) !== 'code-fast' && messageCancelsPendingApproval(trimmed)) {
       const startedAt = Date.now();
@@ -2091,13 +2355,13 @@ async function chat(options = {}) {
     }
 
     const pendingTaskPreview = latestPendingTaskPreview(history);
-    const decision = pendingTaskPreview
-      ? { route: 'cloud', reason: 'pending approval stays on hosted Atris' }
-      : routeDecision(trimmed, { route: options.route });
-    const route = decision.route;
-    if (!(await ensureRuntimeReady(route, decision))) return false;
+    const route = pendingTaskPreview ? 'cloud' : options.route;
+    maybeWriteAtrisGoalBanner(output, cwd);
+    const turnRoute = options.business ? 'cloud' : resolveRoute(trimmed, { route });
+    if (!(await ensureRuntimeReady(turnRoute))) return false;
     const turnFunction = options.turnFunction || turnFunctionForMode(mode);
-    const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId });
+    const turnId = options.turnId || createTurnId();
+    const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId, turnId });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
       ? null
@@ -2158,16 +2422,14 @@ function printBackendHint(options = {}) {
   console.log(formatBackendHint(options));
 }
 
-function backendStartCommand(options = {}) {
-  if (options.explicitLocal) return 'Start your AtrisOS backend, or retry with --cloud for hosted chat.';
-  return 'Start your AtrisOS backend for local workspace, or retry with --cloud for hosted cloud scratch.';
+function backendStartCommand() {
+  return `cd ${process.env.HOME}/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 formatBackendHint(options = {}) {
-  const lines = ['This requires local workspace mode, but no AtrisOS backend is running.'];
-  if (options.routeReason && !options.explicitLocal) lines.push(`Routed local because ${options.routeReason}.`);
-  lines.push(backendStartCommand(options));
-  return lines.join('\n');
+  const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
+  if (route === 'local') return `Start backend:\n${backendStartCommand()}`;
+  return 'Atris cloud did not respond. Check login/network, then rerun ax --doctor.';
 }
 
 function bufferedOutput() {
@@ -2270,7 +2532,7 @@ async function runSelfTest(options = {}) {
     assertSelfTest(!/atris:|fireworks|glm|secret|token/i.test(text), 'doctor output leaked provider/debug text');
   }, results, output);
 
-  await runSelfTestCase('chat backend offline preflight', async () => {
+  await runSelfTestCase('chat cloud offline preflight', async () => {
     const previousAuto = process.env.AX_AUTO_LOG;
     process.env.AX_AUTO_LOG = '0';
     const chunks = [];
@@ -2285,7 +2547,6 @@ async function runSelfTest(options = {}) {
     try {
       await chat({
         mode: 'fast',
-        route: 'local',
         cwd: os.tmpdir(),
         input: Readable.from(['hi\n', 'exit\n']),
         output: chatOutput,
@@ -2306,9 +2567,8 @@ async function runSelfTest(options = {}) {
     const text = chunks.join('');
     assertSelfTest(healthCalls === 1, 'offline preflight repeated unexpectedly');
     assertSelfTest(/backend\s+offline/.test(text), 'offline backend status missing');
-    assertSelfTest(/This requires local workspace mode, but no AtrisOS backend is running\./.test(text), 'local backend hint missing');
-    assertSelfTest(/retry with --cloud for hosted chat/.test(text), 'cloud retry hint missing');
-    assertSelfTest(!/\/Users\/keshavrao/.test(text), 'local backend hint leaked a developer path');
+    assertSelfTest(/Atris cloud unavailable/.test(text), 'cloud offline guidance missing');
+    assertSelfTest(!/Start backend:|uvicorn main:app/.test(text), 'cloud default showed local backend instructions');
     assertSelfTest(!/secret-token/.test(text), 'offline preflight leaked error detail');
   }, results, output);
 
@@ -2947,6 +3207,24 @@ async function main() {
     .join(' ')
     .trim();
 
+  const missionIntent = missionRunIntentFromMessage(prompt);
+  if (missionIntent) {
+    const result = await runLocalMission(missionIntent, {
+      cwd: process.cwd(),
+      onProgress: (line) => {
+        if (/^pursuing /.test(line)) console.log('Pursuing goal...');
+        else if (/^still_running /.test(line)) {
+          const seconds = Number(String(line).split(/\s+/)[1]);
+          console.log(`Still pursuing... ${formatSeconds(seconds)}`);
+        } else if (/^landing /.test(line)) console.log('Landing goal...');
+        else if (/^\[tick /.test(line)) console.log(line);
+      },
+    });
+    console.log(result.text || 'Mission command failed.');
+    if (!result.ok) process.exit(result.status || 1);
+    return;
+  }
+
   let business = null;
   if (businessSlug) {
     if (normalizeMode(mode) === 'code-fast') {
@@ -2994,7 +3272,7 @@ async function main() {
       console.log('');
       console.log(formatRunProfile(buildRunProfile({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route }), process.stdout));
       console.log('');
-      console.log(formatRuntimeHealth(await buildRuntimeHealth(), process.stdout));
+      console.log(formatRuntimeHealth(await buildRuntimeHealth({ route: route === 'auto' ? undefined : route }), process.stdout));
       return;
     }
 
@@ -3021,6 +3299,7 @@ async function main() {
 
     console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
     console.log('');
+    maybeWriteAtrisGoalBanner(process.stdout, process.cwd());
     const result = await turnFunctionForMode(mode)(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
     const receipt = receiptFromState(result);
     const approvalRequest = normalizeMode(mode) === 'code-fast' ? null : approvalRequestFromReceipt(receipt);
@@ -3032,11 +3311,7 @@ async function main() {
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    const decision = prompt
-      ? routeDecision(prompt, { route: route === 'auto' ? undefined : route })
-      : { route: forceLocal ? 'local' : 'cloud', reason: forceLocal ? 'explicit --local' : 'default hosted chat' };
-    const shouldShowBackendHint = decision.route === 'local';
-    if (shouldShowBackendHint) printBackendHint({ routeReason: decision.reason, explicitLocal: forceLocal || decision.reason === 'explicit --local' });
+    printBackendHint({ route: route === 'auto' ? undefined : route });
     process.exit(1);
   }
 }
@@ -3106,7 +3381,6 @@ module.exports = {
   renderStreamingMarkdown,
   renderTerminalMarkdown,
   resolveRoute,
-  shouldPreflightRuntime,
   runBenchmark,
   runSelfTest,
   runtimeReadyForChat,