atris 3.30.0 → 3.30.2

package/ax

@@ -6,46 +6,15 @@ const https = require('https');
 const os = require('os');
 const path = require('path');
 const readline = require('readline');
-const { spawnSync } = require('child_process');
+const crypto = require('crypto');
 const { Readable } = require('stream');
 const { loadCredentials } = require('./utils/auth');
-const {
-  MEMBER_SLUG,
-  loadAxPrefs,
-  setBypassPermissions,
-  resolveBypassPermissions,
-  permissionsLabel,
-} = require('./lib/ax-prefs');
-const {
-  renderShimmerText,
-} = require('./lib/ax-shimmer');
-const {
-  attachMultilineChatInput,
-  stripMultilineCsiText,
-} = require('./lib/ax-chat-input');
-const {
-  accumulateGoalUsage,
-  buildGoalDirective,
-  clearGoalState,
-  createGoalState,
-  evaluateGoalTurn,
-  finishGoalAchieved,
-  formatGoalAchieved,
-  formatGoalActiveBanner,
-  formatGoalContinue,
-  formatGoalStatus,
-  formatGoalStopped,
-  goalBudgetExceeded,
-  goalTurnLimitReached,
-  parseGoalCommand,
-} = require('./lib/ax-goal');
 
 const EXIT_WORDS = new Set(['exit', 'quit', ':q']);
 const BACKEND = {
   host: '127.0.0.1',
   port: 8000,
-  path: '/api/atris2/turn',
-  publicBase: 'https://api.atris.ai'
+  path: '/api/atris2/turn'
 };
 const DEFAULT_BACKEND_BASE = `http://${BACKEND.host}:${BACKEND.port}`;
 const CODE_FAST = {
@@ -56,6 +25,9 @@ const CODE_FAST = {
 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 ATRIS2_HEALTH_PATH = '/api/atris2/health';
+const APPROVAL_EXECUTE_PATH = '/api/atris2/approvals/execute';
+const DEFAULT_APPROVAL_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const CONNECTOR_NAMES = {
   gmail: 'Gmail',
   google_calendar: 'Google Calendar',
@@ -88,22 +60,14 @@ const CONNECTOR_SCOPES = {
 const ANSI = {
   reset: '\x1b[0m',
   bold: '\x1b[1m',
-  italic: '\x1b[3m',
   dim: '\x1b[2m',
   muted: '\x1b[90m',
   accent: '\x1b[36m',
   ok: '\x1b[32m',
-  safe: '\x1b[34m',
-  warn: '\x1b[33m',
-  magenta: '\x1b[35m',
-  underline: '\x1b[4m',
-  strike: '\x1b[9m',
+  magenta: '\x1b[35m'
 };
 
 const TIER_COLORS = { fast: '\x1b[32m', pro: '\x1b[36m', max: '\x1b[35m' };
-const PROGRESS_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-const PROGRESS_START_DELAY_MS = 350;
-const PROGRESS_FRAME_MS = 100;
 
 function tierColor(mode) {
   return TIER_COLORS[mode] || ANSI.accent;
@@ -136,23 +100,11 @@ function tierLabel(mode) {
   return 'Atris 2 Pro';
 }
 
-function formatHeader({ mode = 'fast', cwd = process.cwd(), chat = false, bypassPermissions, goal } = {}, options = {}) {
-  const goalLine = chat && goal ? formatGoalActiveBanner(goal, {
-    paint: (text, codes) => paint(text, codes, options),
-    bold: ANSI.bold,
-    magenta: ANSI.magenta,
-    muted: ANSI.muted,
-    accent: ANSI.accent,
-    ...options,
-  }) : '';
-  const home = os.homedir();
-  const shortCwd = cwd && home && (cwd === home || cwd.startsWith(`${home}/`)) ? `~${cwd.slice(home.length)}` : cwd;
-  const title = paint(`${tierLabel(mode)}${chat ? ' chat' : ''}`, [ANSI.bold, tierColor(normalizeMode(mode))], options);
-  const titleLine = shortCwd ? `${title}${paint(`  ·  ${shortCwd}`, [ANSI.muted], options)}` : title;
+function formatHeader({ mode = 'pro', cwd = process.cwd(), chat = false } = {}, options = {}) {
   return [
-    titleLine,
-    goalLine,
-    chat ? paint('shift+tab permissions · shift+enter newline · ctrl-c · / · exit', [ANSI.muted], options) : '',
+    paint(`${tierLabel(mode)}${chat ? ' chat' : ''}`, [ANSI.bold, tierColor(normalizeMode(mode))], options),
+    cwd,
+    chat ? paint('type / for the menu · /fast /pro /max swap tiers · exit to leave', [ANSI.muted], options) : '',
   ].filter(Boolean).join('\n');
 }
 
@@ -161,57 +113,34 @@ function formatUsage() {
     'ax - Atris local/code agent',
     '',
     'Usage:',
-  '  ax [--fast|--pro|--max|--code-fast] [--local|--cloud] [--bypass|--safe] <message>',
-  '  ax [--fast|--pro|--max|--code-fast] [--local|--cloud] [--bypass|--safe] --chat',
-  '  ax chat [ax] [--fast|--pro|--max]',
-  '  ax spawn <role> --task "..." [--engine manual|codex|claude|cursor|devin]',
-    '  ax spawns [--json]',
-    '  ax youtube <url> [--query "..."] [--json]',
-    '  ax --dogfood-chat [--loops 25] [--json]',
-    '  ax --dogfood-status [--json]',
+    '  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 --approvals',
+    '  ax --approve <approval-id>',
+    '  ax --deny <approval-id>',
+    '  ax --self-test',
     '  ax [--max|--fast] --benchmark',
     '',
     'Modes:',
-    '  --max   hosted Atris 2, highest reasoning, slowest turns',
-    '  --pro   hosted Atris 2, deeper tool loop',
-    '  --fast  hosted Atris 2, faster low-latency turns',
+    '  --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)',
-    '  --bypass  allow external side effects for this run (default: safe / approval-only)',
-    '  --safe    force approval-only mode for this run',
-    '  --dogfood-chat  run the safe ax fast chat checklist harness',
-    '  --dogfood-status  summarize the overnight dogfood mission progress',
-    '',
-    'Chat:',
-    '  /goal <condition>  work autonomously until the condition is met',
-    '  /goal              show active goal, turns, and evaluator reason',
-    '  /goal clear        stop the active goal',
-    '  /bypass  persist bypass mode (external actions allowed when backend supports it)',
-    '  /safe    persist safe mode (default; approval-only external actions)',
-    '',
-    'Delegation:',
-    '  ax spawn <role> --task "..."          create a worker request from ax',
-    '  atris agent spawn <role> --task "..." same request ledger from the Atris CLI',
-    '  ax youtube <url>                     process a YouTube video through Atris',
-    '  ax --dogfood-chat --loops 25         exercise chat UI and routing without spending credits',
-    '  ax --dogfood-status                  show overnight dogfood proof and remaining loops',
     '',
     'Examples:',
-    '  ax spawn worker --task "Fix the failing smoke test" --engine codex',
-    '  ax youtube https://www.youtube.com/watch?v=VIDEO_ID',
-    '  ax --dogfood-chat --loops 25',
-    '  ax --dogfood-status',
     '  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 --approvals',
     '  ax --pro --chat',
   ].join('\n');
 }
@@ -226,9 +155,10 @@ function stripAnsi(value) {
     .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
 }
 
-function createRunLogger({ cwd = process.cwd(), mode = 'fast', kind = 'play', output = process.stdout } = {}) {
+function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', output = process.stdout } = {}) {
   if (process.env.AX_AUTO_LOG === '0') return null;
   if (output !== process.stdout && output !== process.stderr && !output.isTTY) return null;
+  const fullTranscript = process.env.AX_LOG_FULL === '1';
 
   const baseDir = fs.existsSync(path.join(cwd, 'atris'))
     ? path.join(cwd, 'atris', 'runs')
@@ -236,15 +166,22 @@ function createRunLogger({ cwd = process.cwd(), mode = 'fast', kind = 'play', ou
   fs.mkdirSync(baseDir, { recursive: true });
   const logPath = path.join(baseDir, `ax-${kind}-${timestampForFile()}.log`);
   fs.appendFileSync(logPath, [
-    `command: ${process.argv.join(' ')}`,
+    `command: ${fullTranscript ? process.argv.join(' ') : 'ax <redacted>'}`,
     `cwd: ${cwd}`,
     `mode: ${mode}`,
+    `transcript: ${fullTranscript ? 'full' : 'redacted'}`,
     `started_at: ${new Date().toISOString()}`,
     '',
   ].join('\n'));
 
+  let redactedChars = 0;
   const writeLog = (chunk) => {
-    fs.appendFileSync(logPath, stripAnsi(chunk));
+    const text = stripAnsi(chunk);
+    if (fullTranscript) {
+      fs.appendFileSync(logPath, text);
+      return;
+    }
+    redactedChars += text.length;
   };
   const teeOutput = {
     isTTY: Boolean(output && output.isTTY),
@@ -261,56 +198,41 @@ function createRunLogger({ cwd = process.cwd(), mode = 'fast', kind = 'play', ou
     output: teeOutput,
     write: writeLog,
     close(exitCode = 0) {
+      if (!fullTranscript) {
+        fs.appendFileSync(logPath, `redacted_chars: ${redactedChars}\n`);
+        fs.appendFileSync(logPath, 'note: full transcript disabled by default; set AX_LOG_FULL=1 to opt in.\n');
+        fs.appendFileSync(logPath, `exit_code: ${exitCode}\nfinished_at: ${new Date().toISOString()}\n`);
+        return;
+      }
       writeLog(`\nexit_code: ${exitCode}\nfinished_at: ${new Date().toISOString()}\n`);
     }
   };
 }
 
-function backendBaseUrl(options = {}) {
-  const route = options.route === 'local' || options.forceLocal
-    ? 'local'
-    : options.route === 'cloud' || options.forceCloud
-      ? 'cloud'
-      : 'auto';
-  const localOverride = process.env.AX_BACKEND_URL || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL;
-  const cloudOverride = process.env.OBELISK_ATRIS2_BACKEND_URL || process.env.ATRIS_API_BASE || BACKEND.publicBase;
-  if (route === 'cloud') {
-    if (localOverride && !isLoopbackUrl(localOverride)) return localOverride.replace(/\/$/, '');
-    return cloudOverride.replace(/\/$/, '');
-  }
-  if (route === 'auto' && !localOverride) {
-    return cloudOverride.replace(/\/$/, '');
-  }
-  return (localOverride
+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(options = {}) {
-  return new URL(BACKEND.path, backendBaseUrl(options)).toString();
+function backendUrl() {
+  return new URL(BACKEND.path, backendBaseUrl()).toString();
 }
 
-function backendPathUrl(pathname, options = {}) {
-  return new URL(pathname, backendBaseUrl(options)).toString();
+function backendPathUrl(pathname) {
+  return new URL(pathname, backendBaseUrl()).toString();
 }
 
-function codeFastBaseUrl(options = {}) {
-  const route = options.route === 'local' || options.forceLocal
-    ? 'local'
-    : options.route === 'cloud' || options.forceCloud
-      ? 'cloud'
-      : 'auto';
-  const backendOverride = process.env.AX_CODE_FAST_BACKEND_URL;
-  const useBackendOverride = backendOverride && !(route === 'cloud' && isLoopbackUrl(backendOverride));
-  return (useBackendOverride
-    ? backendOverride
-    : process.env.AX_CODE_FAST_API_BASE
-      || process.env.ATRIS_API_BASE
-      || CODE_FAST.publicBase).replace(/\/$/, '');
+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(options = {}) {
-  return new URL(CODE_FAST.path, codeFastBaseUrl(options)).toString();
+function codeFastUrl() {
+  return new URL(CODE_FAST.path, codeFastBaseUrl()).toString();
 }
 
 function isLoopbackUrl(value) {
@@ -322,15 +244,6 @@ function isLoopbackUrl(value) {
   }
 }
 
-function configuredLocalBackendUrl() {
-  return process.env.AX_BACKEND_URL || process.env.OBELISK_LOCAL_ATRIS2_BACKEND_URL || '';
-}
-
-function hasLocalWorkspaceBackend(options = {}) {
-  if (options.localWorkspaceBackend === true) return true;
-  return Boolean(configuredLocalBackendUrl());
-}
-
 function isCodeFastLocal(options = {}) {
   const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
   return route === 'local' && isLoopbackUrl(options.codeFastBaseUrl || codeFastBaseUrl());
@@ -342,44 +255,39 @@ function buildRunProfile(options = {}) {
   if (mode === 'code-fast') {
     const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
     return {
-      endpoint: codeFastUrl({ route }),
+      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 bridge' : 'authenticated Code Fast cloud scratch',
+      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 profileMessage = options.message || 'what files are here?';
-  const route = resolveRoute(profileMessage, options);
-  const payload = buildPayload(profileMessage, { mode, cwd, route, bypassPermissions: options.bypassPermissions });
+  const route = resolveRoute(options.message || 'doctor', options);
+  const payload = buildPayload(options.message || 'doctor', { mode, cwd, route });
   return {
-    endpoint: backendUrl({ route }),
+    endpoint: backendUrl(),
     mode,
     route,
     model: payload.model,
     workspace_path: payload.workspace_path || 'cloud',
     max_turns: payload.max_turns,
-    member_slug: payload.member_slug,
-    bypass_permissions: payload.bypass_permissions,
     streaming: true,
     runtime: route === 'cloud' ? 'authenticated cloud connectors/chat' : 'local workspace',
     reasoning: mode === 'max'
-      ? 'Atris cloud service; Max workspace tool loop uses high reasoning effort'
+      ? 'backend reports run row; Max workspace tool loop uses high reasoning effort'
       : mode === 'pro'
-        ? 'Atris cloud service; Pro workspace tool loop uses API default medium'
-        : 'Atris cloud service; Fast workspace tool loop uses provider default'
+        ? '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],
-    ['agent', profile.member_slug || MEMBER_SLUG],
-    ['permissions', profile.bypass_permissions ? 'bypass' : 'safe'],
     ['endpoint', profile.endpoint],
     ['route', profile.route || 'auto'],
     ['workspace', formatPathSubject(profile.workspace_path, options)],
@@ -391,6 +299,53 @@ function formatRunProfile(profile, options = {}) {
   return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
 }
 
+async function buildRuntimeHealth(options = {}) {
+  const healthRes = options.healthRes
+    ? await Promise.resolve(options.healthRes)
+    : await requestJson(ATRIS2_HEALTH_PATH, { token: '', timeoutMs: options.timeoutMs || 1500 });
+  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;
+  return {
+    schema: 'ax.runtime_health.v1',
+    backend: {
+      ready: Boolean(healthRes.ok && data.ready),
+      reachable: Boolean(healthRes.ok),
+      status: healthRes.status || 0,
+      error: healthRes.error || '',
+    },
+    fast: {
+      ready: Boolean(fast && fast.ready),
+      route_ready: Boolean(fast && fast.ready),
+    },
+    permissions: {
+      approval_execution_path: APPROVAL_EXECUTE_PATH,
+      ready: Boolean(healthRes.ok),
+    },
+  };
+}
+
+function formatRuntimeHealth(health, options = {}) {
+  const backendReady = health && health.backend && health.backend.ready;
+  const backendReachable = health && health.backend && health.backend.reachable;
+  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'],
+    ['fast', fastReady ? 'ready' : 'not ready'],
+    ['approvals', permissionReady ? 'ready' : 'offline'],
+  ];
+  if (!backendReachable) rows.push(['fix', 'start local backend, then rerun ax --doctor']);
+  return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
+}
+
+function runtimeReadyForChat(health, mode = 'fast') {
+  if (!health || !health.backend || !health.permissions) return false;
+  if (!health.backend.ready || !health.permissions.ready) return false;
+  if (normalizeMode(mode) === 'fast' && (!health.fast || health.fast.ready === false)) return false;
+  return true;
+}
+
 function canonicalConnectorId(value) {
   return String(value || '').trim().toLowerCase().replace(/-/g, '_');
 }
@@ -423,9 +378,9 @@ function authUserId() {
   }
 }
 
-function isLoopbackBackend(options = {}) {
+function isLoopbackBackend() {
   try {
-    const parsed = new URL(backendBaseUrl(options));
+    const parsed = new URL(backendBaseUrl());
     return ['127.0.0.1', 'localhost', '::1'].includes(parsed.hostname);
   } catch (_) {
     return false;
@@ -467,6 +422,48 @@ function requestJson(pathname, { token = authToken(), timeoutMs = 6000 } = {}) {
   });
 }
 
+function postJson(pathname, body, { token = authToken(), timeoutMs = 30000 } = {}) {
+  const url = backendPathUrl(pathname);
+  const parsed = new URL(url);
+  const transport = parsed.protocol === 'https:' ? https : http;
+  const postData = JSON.stringify(body || {});
+  return new Promise((resolve) => {
+    const req = transport.request({
+      method: 'POST',
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: `${parsed.pathname}${parsed.search}`,
+      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 text = Buffer.concat(chunks).toString('utf8');
+        let data = null;
+        try {
+          data = text ? JSON.parse(text) : null;
+        } catch (_) {
+          resolve({ ok: false, status: res.statusCode, data: null, text });
+          return;
+        }
+        resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, data, 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.write(postData);
+    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' };
@@ -594,7 +591,7 @@ function mentionsConnector(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 || '');
+  return mentionsConnector(message) && /\b(add|send|post|dm|message|reply|draft|compose|schedule|book|create|update|delete|archive|move|share|comment|invite)\b/i.test(message || '');
 }
 
 function workspaceIntent(message) {
@@ -607,220 +604,24 @@ function githubWorkspaceIntent(message) {
   return /\b(push|commit|commits?|branch|branches|checkout|merge|rebase|tag|release|pr|pull request|pull-request|repo change|code change|small change)\b/i.test(text);
 }
 
-function casualChatIntent(message) {
-  const text = String(message || '').trim();
-  if (!text) return false;
-  if (workspaceIntent(text) || mentionsConnector(text) || githubWorkspaceIntent(text)) return false;
-  if (/^(hi+|hello+|hey+|yo+|sup|gm|good morning|good afternoon|good evening|thanks?|thank you|ok+|okay|k|cool|nice|lol|lmao|haha|why\??|what\??|huh\??|yes|no|nah|yep|nope)[.!?]*$/i.test(text)) return true;
-  if (/^(hi|hello|hey)\b/i.test(text)) return true;
-  return /^[a-z]{1,8}[.!?]*$/i.test(text);
-}
-
 function resolveRoute(message, options = {}) {
   if (options.route === 'local' || options.forceLocal) return 'local';
   if (options.route === 'cloud' || options.forceCloud) return 'cloud';
-  if (casualChatIntent(message)) return 'cloud';
-  const localWorkspace = hasLocalWorkspaceBackend(options);
-  if (githubWorkspaceIntent(message) && localWorkspace) return 'local';
+  if (githubWorkspaceIntent(message)) return 'local';
   if (mentionsConnector(message) && !workspaceIntent(message)) return 'cloud';
-  if (!localWorkspace) return 'cloud';
   return 'local';
 }
 
 function normalizeMode(mode) {
   if (mode === 'code-fast' || mode === 'code') return 'code-fast';
   if (mode === 'max') return 'max';
-  if (mode === 'pro') return 'pro';
-  return 'fast';
+  return mode === 'fast' ? 'fast' : 'pro';
 }
 
 function formatPrompt(mode, options = {}) {
+  if (!mode) return '› ';
   const tier = normalizeMode(mode);
-  const goalHint = options.goal && options.goal.active
-    ? `${paint('◎ ', [ANSI.bold, ANSI.magenta], options)}`
-    : '';
-  if (!mode) return `${goalHint}› `;
-  return `${goalHint}${paint(tier, [ANSI.bold, tierColor(tier)], options)} › `;
-}
-
-function terminalWidth(options = {}) {
-  const cols = Number(options.columns || process.stdout.columns || 0);
-  if (Number.isFinite(cols) && cols >= 48) return cols;
-  return 72;
-}
-
-function inputBoxPlainWidth(options = {}) {
-  const cols = Number(options.columns || process.stdout.columns || 0);
-  if (Number.isFinite(cols) && cols >= 48) return cols - 1;
-  return 71;
-}
-
-function inputBoxLayoutOptions(stream, overrides = {}) {
-  const cols = Number(stream?.columns || process.stdout.columns || 0);
-  return {
-    ...overrides,
-    columns: Number.isFinite(cols) && cols >= 48 ? cols - 1 : 71,
-    isTTY: stream?.isTTY ?? process.stdout.isTTY,
-  };
-}
-
-function buildInputBoxTopPlain(options = {}) {
-  const width = inputBoxPlainWidth(options);
-  return `╭${'─'.repeat(Math.max(0, width - 2))}╮`;
-}
-
-// The mode + newline affordance lives on its own line BELOW the box (claude
-// style), so the rules above/below stay clean and we never say "enter send".
-function buildInputBoxStatusPlain(options = {}) {
-  return `  ${formatPermissionModeBrief(options)} · shift+enter`;
-}
-
-function buildInputBoxBottomPlain(options = {}) {
-  const width = inputBoxPlainWidth(options);
-  return `╰${'─'.repeat(Math.max(0, width - 2))}╯`;
-}
-
-function formatInputBoxInputRow(prompt, line, options = {}) {
-  const width = inputBoxPlainWidth(options);
-  const promptPlain = stripAnsi(prompt);
-  const linePlain = stripAnsi(String(line || ''));
-  const rightBar = paint('│', [ANSI.dim, ANSI.muted], options);
-  const rightPlain = '│';
-  const pad = Math.max(0, width - promptPlain.length - linePlain.length - rightPlain.length);
-  return `${prompt}${line}${' '.repeat(pad)}${rightBar}`;
-}
-
-function formatPermissionModeBrief(options = {}) {
-  return resolveBypassPermissions(options) ? 'full access' : 'approve';
-}
-
-function permissionAccentCodes(options = {}) {
-  return resolveBypassPermissions(options) ? [ANSI.dim, ANSI.warn] : [ANSI.dim, ANSI.safe];
-}
-
-function formatPermissionToggleMessage(bypassPermissions, options = {}) {
-  const persistPrefs = options.persistPrefs !== false;
-  const suffix = persistPrefs ? ' (saved)' : ' (session)';
-  if (bypassPermissions) {
-    return paint(`· Full access${suffix} — external actions can run without approval`, [ANSI.warn], options);
-  }
-  return paint(`· Approve mode${suffix} — external actions ask before they run`, [ANSI.safe], options);
-}
-
-function isPermissionToggleKey(key) {
-  if (!key) return false;
-  if (key.shift && key.name === 'tab') return true;
-  const sequence = String(key.sequence || '');
-  return sequence === '\x1b[Z' || sequence === '\x1b[1;2Z';
-}
-
-function isMultilineInsertKey(str, key) {
-  if (!key) return str === '\n';
-  if (key.shift && (key.name === 'return' || key.name === 'enter')) return true;
-  if (key.meta && (key.name === 'return' || key.name === 'enter')) return true;
-  if (str === '\n' && key.name !== 'return') return true;
-  return false;
-}
-
-function insertMultilineBreak(rl) {
-  if (!rl) return;
-  // Insert a literal newline at the cursor. rl.write('\n') would SUBMIT the
-  // line (readline treats it as Enter) and also re-enter our _ttyWrite hook.
-  if (typeof rl._insertString === 'function') {
-    rl._insertString('\n');
-    return;
-  }
-  if (typeof rl.line === 'string') {
-    const cursor = Number.isFinite(rl.cursor) ? rl.cursor : rl.line.length;
-    rl.line = rl.line.slice(0, cursor) + '\n' + rl.line.slice(cursor);
-    rl.cursor = cursor + 1;
-    if (typeof rl._refreshLine === 'function') rl._refreshLine();
-  }
-}
-
-function formatInputBoxTop(options = {}) {
-  return paint(buildInputBoxTopPlain(options), [ANSI.dim, ANSI.muted], options);
-}
-
-function formatInputBoxBottom(options = {}) {
-  return paint(buildInputBoxBottomPlain(options), [ANSI.dim, ANSI.muted], options);
-}
-
-// Status line shown below the box: permission mode + the shift+enter newline
-// affordance, mode-colored. Drawn by the repaint, cleared on submit.
-function formatInputBoxStatus(options = {}) {
-  const plain = buildInputBoxStatusPlain(options);
-  const modeLabel = formatPermissionModeBrief(options);
-  const idx = plain.indexOf(modeLabel);
-  if (idx === -1) return paint(plain, [ANSI.dim, ANSI.muted], options);
-  const modePainted = paint(modeLabel, permissionAccentCodes(options), options);
-  const dim = [ANSI.dim, ANSI.muted];
-  return `${paint(plain.slice(0, idx), dim, options)}${modePainted}${paint(plain.slice(idx + modeLabel.length), dim, options)}`;
-}
-
-function closeInputBox(output, options = {}) {
-  // On submit the cursor sits on the bottom-rule row: redraw the rule, then
-  // clear the status line the repaint left below it and leave the cursor on a
-  // fresh row for the turn output.
-  output.write(`\r\x1b[2K${formatInputBoxBottom(options)}\n\x1b[2K\r`);
-}
-
-// Keep the input box closed while the user is typing: after each readline
-// render, repaint the bottom rule one row below the (possibly wrapped/multiline)
-// input plus a status line below that, then return the cursor. readline clears
-// to end-of-display on every refresh, so both must be redrawn each time. Writes
-// to the raw stream readline renders to (not the logger) since these are
-// transient cursor moves.
-function repaintInputBoxBottom(rl, output, options = {}) {
-  if (!rl || !output || typeof output.write !== 'function') return;
-  if (typeof rl._getDisplayPos !== 'function' || typeof rl.getCursorPos !== 'function') return;
-  let total;
-  let cur;
-  try {
-    total = rl._getDisplayPos(`${rl._prompt || ''}${rl.line || ''}`);
-    cur = rl.getCursorPos();
-  } catch {
-    return;
-  }
-  if (!total || !cur) return;
-  // When the input is taller than the viewport the terminal scrolls and the
-  // relative cursor math below can't land the rule reliably (it would corrupt
-  // the scrollback). Degrade gracefully: skip the closing rule for a giant
-  // input rather than scramble it. readline still renders the text correctly.
-  const rows = Number(output.rows || (typeof process !== 'undefined' && process.stdout && process.stdout.rows) || 0);
-  if (rows && total.rows + 3 >= rows) return;
-  const down = Math.max(1, (total.rows - cur.rows) + 1);
-  let seq = `\r\x1b[${down}B\x1b[2K${formatInputBoxBottom(options)}`;
-  seq += `\r\x1b[1B\x1b[2K${formatInputBoxStatus(options)}`;
-  seq += `\x1b[${down + 1}A\r`;
-  if (cur.cols > 0) seq += `\x1b[${cur.cols}C`;
-  output.write(seq);
-}
-
-function formatChatInputInnerPrefix(mode, options = {}) {
-  const tier = normalizeMode(mode);
-  const goalHint = options.goal && options.goal.active
-    ? `${paint('◎ ', [ANSI.bold, ANSI.magenta], options)}`
-    : '';
-  const tierPart = mode
-    ? `${goalHint}${paint(tier, [ANSI.bold, tierColor(tier)], options)} › `
-    : `${goalHint}› `;
-  return `${paint('→ ', [ANSI.muted], options)}${tierPart}`;
-}
-
-function formatChatInputPrompt(mode, options = {}) {
-  // Two-space indent (no left bar) to match the plain rules and the status line.
-  return `  ${formatChatInputInnerPrefix(mode, options)}`;
-}
-
-const PERMISSION_COMMANDS = new Map([
-  ['/bypass', true],
-  ['/safe', false],
-]);
-
-function chatPermissionCommand(line) {
-  const key = String(line || '').trim().toLowerCase();
-  return PERMISSION_COMMANDS.has(key) ? PERMISSION_COMMANDS.get(key) : null;
+  return `${paint(tier, [ANSI.bold, tierColor(tier)], options)} › `;
 }
 
 const TIER_COMMANDS = new Map([
@@ -834,70 +635,21 @@ function chatTierCommand(line) {
 }
 
 const CHAT_COMMANDS = [
-  ['/goal', 'set/show autonomous completion condition'],
   ['/fast', 'quick answers, lowest latency'],
   ['/pro', 'deeper tool loop for real work'],
   ['/max', 'highest reasoning for the hardest jobs'],
-  ['/bypass', 'allow external side effects (persisted)'],
-  ['/safe', 'approval-only external actions (default, persisted)'],
   ['/help', 'show this menu'],
   ['exit', 'leave chat'],
 ];
 
-const CHAT_SHORTCUTS = [
-  ['shift+tab', 'toggle approve ↔ full access'],
-  ['shift+enter', 'new line (enter sends)'],
-];
-
-const CHAT_DOGFOOD_BASE_CASES = [
-  { input: '/help', kind: 'command', coverage: 'menu' },
-  { input: '/fast', kind: 'command', coverage: 'tier_fast' },
-  { input: 'hi', kind: 'turn', expectRoute: 'cloud', coverage: 'small_talk' },
-  { input: 'pop', kind: 'turn', expectRoute: 'cloud', coverage: 'short_noise' },
-  { input: 'hello why', kind: 'turn', expectRoute: 'cloud', coverage: 'greeting_phrase' },
-  { input: 'what files are here?', kind: 'turn', expectRoute: 'cloud', coverage: 'workspace_read' },
-  { input: 'search src for the input component', kind: 'turn', expectRoute: 'cloud', coverage: 'workspace_search' },
-  { input: 'fix the xp game tests', kind: 'turn', expectRoute: 'cloud', coverage: 'workspace_fix' },
-  { input: 'what is on my calendar today?', kind: 'turn', expectRoute: 'cloud', coverage: 'connector_read' },
-  { input: 'which integrations are connected?', kind: 'turn', expectRoute: 'cloud', coverage: 'connector_status' },
-  { input: 'what github repos do I have?', kind: 'turn', expectRoute: 'cloud', coverage: 'github_read' },
-  { input: 'push something to github', kind: 'turn', expectRoute: 'cloud', coverage: 'github_workspace_mutation' },
-  { input: 'https://www.youtube.com/watch?v=gBukk9LIklc', kind: 'youtube', coverage: 'youtube_url' },
-  { input: '/max', kind: 'command', coverage: 'tier_max' },
-  { input: 'refactor this module and verify the tests', kind: 'turn', expectRoute: 'cloud', expectMode: 'max', coverage: 'max_cloud' },
-  { input: '/pro', kind: 'command', coverage: 'tier_pro' },
-  { input: 'send a slack message to the team', kind: 'turn', expectRoute: 'cloud', expectMode: 'pro', coverage: 'connector_write_safe' },
-  { input: '/bypass', kind: 'command', coverage: 'permission_bypass' },
-  { input: 'send a slack message to the team', kind: 'turn', expectRoute: 'cloud', expectBypass: true, coverage: 'connector_write_bypass' },
-  { input: '/safe', kind: 'command', coverage: 'permission_safe' },
-  { input: 'send a slack message to the team', kind: 'turn', expectRoute: 'cloud', expectBypass: false, coverage: 'connector_write_resafe' },
-  { input: '/wat', kind: 'command', coverage: 'unknown_slash' },
-  { input: '/goal', kind: 'command', coverage: 'goal_status' },
-  { input: 'oj', kind: 'turn', expectRoute: 'cloud', coverage: 'short_noise_repeat' },
-  { input: 'read MAP.md and do not edit', kind: 'turn', expectRoute: 'cloud', coverage: 'workspace_read_specific' },
-];
-
-function buildChatDogfoodCases(loopCount = 25) {
-  const count = Math.max(1, Number(loopCount) || 25);
-  const cases = [];
-  for (let i = 0; i < count; i += 1) {
-    cases.push({ ...CHAT_DOGFOOD_BASE_CASES[i % CHAT_DOGFOOD_BASE_CASES.length], index: i + 1 });
-  }
-  return cases;
-}
-
 function chatMenu(options = {}) {
-  const commands = CHAT_COMMANDS
+  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');
-  const shortcuts = CHAT_SHORTCUTS
-    .map(([name, desc]) => `  ${paint(name.padEnd(6), [ANSI.ok], options)}  ${paint(desc, [ANSI.muted], options)}`)
-    .join('\n');
-  return `${commands}\n${shortcuts}`;
 }
 
 function chatCompleter(line) {
@@ -908,132 +660,10 @@ function chatCompleter(line) {
   return [hits.length ? hits : names, trimmed];
 }
 
-function parsePermissionFlags(args) {
-  let bypassPermissions;
-  if (args.includes('--bypass')) bypassPermissions = true;
-  if (args.includes('--safe')) bypassPermissions = false;
-  return bypassPermissions;
-}
-
-function stripPermissionFlags(args) {
-  return args.filter(arg => arg !== '--bypass' && arg !== '--safe');
-}
-
-function normalizeChatCommandArgs(args = []) {
-  const normalized = [...args];
-  let firstPositional = -1;
-  const flagsWithValue = new Set(['--business', '--verify', '--loops']);
-
-  for (let i = 0; i < normalized.length; i += 1) {
-    const arg = String(normalized[i] || '');
-    if (flagsWithValue.has(arg)) {
-      i += 1;
-      continue;
-    }
-    if (arg.startsWith('-')) continue;
-    firstPositional = i;
-    break;
-  }
-
-  let chatRequested = normalized.includes('--chat');
-  if (firstPositional !== -1 && normalized[firstPositional] === 'chat') {
-    chatRequested = true;
-    normalized.splice(firstPositional, 1, '--chat');
-    const target = String(normalized[firstPositional + 1] || '').toLowerCase();
-    if (target === MEMBER_SLUG || target === 'ax') {
-      normalized.splice(firstPositional + 1, 1);
-    }
-  }
-
-  return { args: normalized, chatRequested };
-}
-
-function isAxSpawnCommand(command) {
-  return ['spawn', 'spawns', 'spawn-list', 'list-spawns', 'spawn-status', 'spawn-show'].includes(String(command || ''));
-}
-
-function runAxSpawnCommand(args = [], deps = {}) {
-  const [command, ...rest] = args;
-  const root = deps.root || process.cwd();
-  const output = deps.output || ((line = '') => console.log(line));
-  const {
-    agentSpawnCommand,
-    agentSpawnListCommand,
-    agentSpawnStatusCommand,
-  } = require('./commands/agent-spawn');
-
-  if (command === 'spawn') return agentSpawnCommand(rest, { root, output, commandName: 'ax spawn' });
-  if (command === 'spawns' || command === 'spawn-list' || command === 'list-spawns') {
-    return agentSpawnListCommand(rest, { root, output });
-  }
-  if (command === 'spawn-status' || command === 'spawn-show') {
-    return agentSpawnStatusCommand(rest, { root, output });
-  }
-  throw new Error('Unknown ax spawn command');
-}
-
-const YOUTUBE_URL_PATTERN = /\bhttps?:\/\/(?:www\.)?(?:youtube\.com\/watch\?[^\s]+|youtu\.be\/[^\s]+|youtube\.com\/shorts\/[^\s]+)/i;
-
-function cleanYoutubeUrl(url) {
-  return String(url || '').replace(/[),.;\]]+$/g, '');
-}
-
-function extractYoutubeUrl(text) {
-  const match = String(text || '').match(YOUTUBE_URL_PATTERN);
-  return match ? cleanYoutubeUrl(match[0]) : null;
-}
-
-function youtubeQueryFromPrompt(prompt, youtubeUrl) {
-  const withoutUrl = String(prompt || '').replace(youtubeUrl, '').trim();
-  return withoutUrl.replace(/^[-:,\s]+|[-:,\s]+$/g, '').trim();
-}
-
-function buildAxYoutubeArgs(prompt, extraArgs = []) {
-  const text = Array.isArray(prompt) ? prompt.join(' ') : String(prompt || '');
-  const youtubeUrl = extractYoutubeUrl(text);
-  if (!youtubeUrl) return null;
-  const query = youtubeQueryFromPrompt(text, youtubeUrl);
-  const args = [youtubeUrl];
-  if (query) args.push('--query', query);
-  return args.concat(extraArgs || []);
-}
-
-async function runAxYoutubeCommand(args = [], deps = {}) {
-  const output = deps.output || ((line = '') => console.log(line));
-  const commandArgs = args[0] === 'youtube' ? args.slice(1) : args;
-  const inferred = args[0] === 'youtube' ? null : buildAxYoutubeArgs(commandArgs);
-  const finalArgs = inferred || commandArgs;
-  const youtubeCommand = deps.youtubeCommand || require('./commands/youtube').youtubeCommand;
-  const commandName = args[0] === 'youtube' ? 'ax youtube' : deps.commandName;
-  return youtubeCommand(finalArgs, { ...deps, output, commandName });
-}
-
-function normalizeWorkingOptions(frameOrOptions, maybeOptions = {}) {
-  if (typeof frameOrOptions === 'string') {
-    return { ...maybeOptions, frameChar: frameOrOptions };
-  }
-  if (frameOrOptions && typeof frameOrOptions === 'object') {
-    return frameOrOptions;
-  }
-  return maybeOptions;
-}
-
-function formatWorkingLine(ms, verb, frameOrOptions, maybeOptions = {}) {
-  const options = normalizeWorkingOptions(frameOrOptions, maybeOptions);
+function formatWorkingLine(ms, verb, frame) {
   const totalSeconds = Math.max(1, Math.round((Number(ms) || 0) / 1000));
-  const tick = Number.isFinite(options.tick) ? options.tick : null;
-  const labelVerb = String(verb || 'Thinking').trim() || 'Thinking';
-  const meta = paint(
-    `(${formatSeconds(totalSeconds)} · ctrl-c to interrupt)`,
-    [ANSI.dim, ANSI.muted],
-    options
-  );
-  const label = tick === null
-    ? paint(labelVerb, [ANSI.muted], options)
-    : renderShimmerText(labelVerb, tick ?? 0, options);
-  const suffix = paint('…', [ANSI.dim, ANSI.muted], options);
-  const prefix = paint('•', [ANSI.muted], options);
-  return `${prefix} ${label}${suffix} ${meta}`;
+  if (verb) return `${frame || '•'} ${verb}… (${formatSeconds(totalSeconds)} · ctrl-c to interrupt)`;
+  return `• Working (${formatSeconds(totalSeconds)} • ctrl-c to interrupt)`;
 }
 
 function verbForTool(tool) {
@@ -1042,8 +672,7 @@ function verbForTool(tool) {
   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';
-  if (name.includes('think') || name.includes('reason') || name === 'task') return 'Thinking';
-  return 'Thinking';
+  return 'Working';
 }
 
 function formatDoneLine(ms, credits) {
@@ -1065,18 +694,7 @@ function paint(text, codes, options = {}) {
   return `${codes.join('')}${text}${ANSI.reset}`;
 }
 
-function formatMarkdownLink(label, url, options = {}) {
-  const display = String(label || '').trim();
-  const href = String(url || '').trim();
-  if (!href) return display;
-  const colored = paint(display, [ANSI.accent, ANSI.underline], options);
-  if (useColor(options) && (/^(https?:\/\/|file:\/\/)/i.test(href) || href.startsWith('/'))) {
-    return hyperlinkPath(colored, href, options);
-  }
-  return `${display} (${href})`;
-}
-
-function renderTerminalInline(text, options = {}) {
+function renderTerminalMarkdown(text, options = {}) {
   let rendered = String(text || '');
   const codeSpans = [];
   rendered = rendered.replace(/`([^`\n]+)`/g, (_, code) => {
@@ -1084,131 +702,23 @@ function renderTerminalInline(text, options = {}) {
     codeSpans.push(code);
     return token;
   });
-  rendered = rendered.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => formatMarkdownLink(label, url, options));
-  rendered = rendered.replace(/\*\*\*([^*\n]+)\*\*\*/g, (_, value) => paint(value, [ANSI.bold, ANSI.italic], options));
+  rendered = rendered.replace(/^#{1,6}\s+(.+)$/gm, (_, title) => paint(title, [ANSI.bold], options));
   rendered = rendered.replace(/\*\*([^*\n]+)\*\*/g, (_, value) => paint(value, [ANSI.bold], options));
   rendered = rendered.replace(/__([^_\n]+)__/g, (_, value) => paint(value, [ANSI.bold], options));
-  rendered = rendered.replace(/~~([^~\n]+)~~/g, (_, value) => paint(value, [ANSI.strike], options));
-  rendered = rendered.replace(/\*([^*\n]+)\*/g, (_, value) => paint(value, [ANSI.italic], options));
-  rendered = rendered.replace(/_([^_\n]+)_/g, (_, value) => paint(value, [ANSI.italic], options));
   rendered = rendered.replace(/\u0000CODE(\d+)\u0000/g, (_, index) => paint(codeSpans[Number(index)] || '', [ANSI.accent], options));
   return rendered;
 }
 
-function renderTerminalBlockLine(line, options = {}) {
-  const header = line.match(/^(#{1,6})\s+(.+)$/);
-  if (header) return paint(header[2], [ANSI.bold], options);
-
-  const list = line.match(/^(\s*)(?:[*+-]|\d+\.)\s+(.*)$/);
-  if (list) {
-    const bullet = paint('•', [ANSI.accent], options);
-    return `${list[1]}${bullet} ${renderTerminalInline(list[2], options)}`;
-  }
-
-  const quote = line.match(/^>\s?(.*)$/);
-  if (quote) {
-    return `${paint('▏ ', [ANSI.muted], options)}${renderTerminalInline(quote[1], options)}`;
-  }
-
-  if (/^(\*{3,}|-{3,}|_{3,})$/.test(line.trim())) {
-    const width = Math.min(Math.max(16, terminalWidth(options) - 4), 48);
-    return paint('─'.repeat(width), [ANSI.dim, ANSI.muted], options);
-  }
-
-  return renderTerminalInline(line, options);
-}
-
-function renderTerminalMarkdown(text, options = {}) {
-  const source = String(text || '');
-  const parts = [];
-  const fence = /```[^\n]*\n([\s\S]*?)```/g;
-  let last = 0;
-  let match = fence.exec(source);
-  while (match) {
-    if (match.index > last) {
-      parts.push({ kind: 'text', value: source.slice(last, match.index) });
-    }
-    parts.push({ kind: 'code', value: match[1] || '' });
-    last = match.index + match[0].length;
-    match = fence.exec(source);
-  }
-  if (last < source.length) parts.push({ kind: 'text', value: source.slice(last) });
-
-  return parts.map((part) => {
-    if (part.kind === 'code') {
-      return part.value
-        .replace(/\n$/, '')
-        .split('\n')
-        .map((line) => paint(`  ${line}`, [ANSI.muted], options))
-        .join('\n');
-    }
-    return part.value
-      .split('\n')
-      .map((line) => renderTerminalBlockLine(line, options))
-      .join('\n');
-  }).join('\n');
-}
-
-function renderFenceBuffer(buffer, options = {}) {
-  return String(buffer || '')
-    .replace(/\n$/, '')
-    .split('\n')
-    .map((line) => paint(`  ${line}`, [ANSI.muted], options))
-    .join('\n');
-}
-
 function resetMarkdownState(state) {
   state.markdownMode = 'normal';
   state.markdownBuffer = '';
   state.markdownCarry = '';
-  state.markdownDelim = '';
-  state.atLineStart = true;
 }
 
 function ensureMarkdownState(state) {
   if (!state.markdownMode) state.markdownMode = 'normal';
   if (typeof state.markdownBuffer !== 'string') state.markdownBuffer = '';
   if (typeof state.markdownCarry !== 'string') state.markdownCarry = '';
-  if (typeof state.markdownDelim !== 'string') state.markdownDelim = '';
-  if (typeof state.atLineStart !== 'boolean') state.atLineStart = true;
-}
-
-function streamingListMarkerAt(input, index) {
-  const rest = input.slice(index);
-  const match = rest.match(/^(\s*)(?:[*+-]|\d+\.)\s+/);
-  if (!match) return null;
-  return { length: match[0].length, indent: match[1] || '' };
-}
-
-function streamingHeadingAt(input, index) {
-  const rest = input.slice(index);
-  const match = rest.match(/^#{1,6}\s+([^\n]*)/);
-  if (!match) return null;
-  return { length: match[0].length, title: match[1] || '' };
-}
-
-function streamingBlockquoteAt(input, index) {
-  const rest = input.slice(index);
-  const match = rest.match(/^>\s?/);
-  if (!match) return null;
-  return { length: match[0].length };
-}
-
-function streamingHorizontalRuleAt(input, index) {
-  const rest = input.slice(index);
-  const match = rest.match(/^(-{3,}|\*{3,}|_{3,})(?=\n|$)/);
-  if (!match) return null;
-  return { length: match[0].length };
-}
-
-function streamingLinkAt(input, index, options) {
-  const rest = input.slice(index);
-  const match = rest.match(/^\[([^\]]+)\]\(([^)]+)\)/);
-  if (!match) return null;
-  return {
-    length: match[0].length,
-    rendered: formatMarkdownLink(match[1], match[2], options),
-  };
 }
 
 function renderStreamingMarkdown(state, text, options = {}) {
@@ -1218,239 +728,43 @@ function renderStreamingMarkdown(state, text, options = {}) {
   let out = '';
 
   for (let i = 0; i < input.length;) {
-    if (state.markdownMode === 'fence') {
-      if (state.atLineStart) {
-        const rest = input.slice(i);
-        if (/^```/.test(rest)) {
-          out += renderFenceBuffer(state.markdownBuffer, options);
-          state.markdownBuffer = '';
-          state.markdownMode = 'normal';
-          const nl = rest.indexOf('\n');
-          if (nl === -1) { i = input.length; state.atLineStart = true; continue; }
-          out += '\n';
-          i += nl + 1;
-          state.atLineStart = true;
-          continue;
-        }
-        if (/^`{1,3}$/.test(rest)) { state.markdownCarry = rest; break; }
-      }
-      const c = input[i];
-      state.markdownBuffer += c;
-      state.atLineStart = c === '\n';
-      i += 1;
-      continue;
-    }
-
-    if (state.markdownMode === 'normal' && state.atLineStart) {
-      const rest = input.slice(i);
-      // Code fence ```lang … ``` — wait for the full opening line, then stream
-      // the body as an indented block (handled by the 'fence' branch above).
-      if (/^```/.test(rest)) {
-        const nl = rest.indexOf('\n');
-        if (nl === -1) { state.markdownCarry = rest; break; }
-        state.markdownMode = 'fence';
-        state.markdownBuffer = '';
-        state.atLineStart = true;
-        i += nl + 1;
-        continue;
-      }
-      // Incomplete block marker at the end of this delta (heading ##, fence ```,
-      // bullet - / +, numbered 1.) — carry it so the next delta completes the
-      // marker instead of leaking it as plain text.
-      if (/^(?:#{1,6}|`{1,3}|[-+]|\d{1,9}\.)$/.test(rest)) { state.markdownCarry = rest; break; }
-
-      const heading = streamingHeadingAt(input, i);
-      if (heading) {
-        out += paint(heading.title, [ANSI.bold], options);
-        i += heading.length;
-        if (input[i] === '\n') {
-          out += '\n';
-          i += 1;
-          state.atLineStart = true;
-        } else {
-          state.atLineStart = false;
-        }
-        continue;
-      }
-      const list = streamingListMarkerAt(input, i);
-      if (list) {
-        out += `${list.indent}${paint('•', [ANSI.accent], options)} `;
-        i += list.length;
-        state.atLineStart = false;
-        continue;
-      }
-      const quote = streamingBlockquoteAt(input, i);
-      if (quote) {
-        out += paint('▏ ', [ANSI.muted], options);
-        i += quote.length;
-        state.atLineStart = false;
-        continue;
-      }
-      const hr = streamingHorizontalRuleAt(input, i);
-      if (hr) {
-        const width = Math.min(Math.max(16, terminalWidth(options) - 4), 48);
-        out += paint('─'.repeat(width), [ANSI.dim, ANSI.muted], options);
-        i += hr.length;
-        if (input[i] === '\n') {
-          out += '\n';
-          i += 1;
-          state.atLineStart = true;
-        } else {
-          state.atLineStart = false;
-        }
-        continue;
-      }
-    }
-
     const char = input[i];
     const next = input[i + 1];
-    const third = input[i + 2];
 
     if (state.markdownMode === 'normal') {
-      const link = streamingLinkAt(input, i, options);
-      if (link) {
-        out += link.rendered;
-        i += link.length;
-        state.atLineStart = false;
-        continue;
-      }
-      if (char === '[') {
-        state.markdownCarry = '[';
+      if (char === '*' && next === undefined) {
+        state.markdownCarry = '*';
         break;
       }
-      if (char === '*' && next === '*' && third === '*') {
-        state.markdownMode = 'bold_italic';
-        state.markdownBuffer = '';
-        state.markdownDelim = '***';
-        i += 3;
-        continue;
-      }
       if (char === '*' && next === '*') {
         state.markdownMode = 'bold';
         state.markdownBuffer = '';
-        state.markdownDelim = '**';
-        i += 2;
-        continue;
-      }
-      if (char === '*') {
-        if (next === undefined) {
-          state.markdownCarry = '*';
-          break;
-        }
-        state.markdownMode = 'italic';
-        state.markdownBuffer = '';
-        state.markdownDelim = '*';
-        i += 1;
-        continue;
-      }
-      if (char === '_' && next === '_') {
-        state.markdownMode = 'bold';
-        state.markdownBuffer = '';
-        state.markdownDelim = '__';
-        i += 2;
-        continue;
-      }
-      if (char === '_') {
-        if (next === undefined) {
-          state.markdownCarry = '_';
-          break;
-        }
-        state.markdownMode = 'italic';
-        state.markdownBuffer = '';
-        state.markdownDelim = '_';
-        i += 1;
-        continue;
-      }
-      if (char === '~' && next === '~') {
-        state.markdownMode = 'strike';
-        state.markdownBuffer = '';
-        state.markdownDelim = '~~';
         i += 2;
         continue;
       }
       if (char === '`') {
         state.markdownMode = 'code';
         state.markdownBuffer = '';
-        state.markdownDelim = '`';
         i += 1;
         continue;
       }
       out += char;
-      if (char === '\n') state.atLineStart = true;
-      else state.atLineStart = false;
       i += 1;
       continue;
     }
 
-    if (state.markdownMode === 'bold_italic') {
-      if (char === '*' && next === '*' && third === '*') {
-        out += paint(state.markdownBuffer, [ANSI.bold, ANSI.italic], options);
-        state.markdownMode = 'normal';
-        state.markdownBuffer = '';
-        state.markdownDelim = '';
-        i += 3;
-        continue;
-      }
+    if (state.markdownMode === 'bold') {
       if (char === '*' && next === undefined) {
         state.markdownCarry = '*';
         break;
       }
-      state.markdownBuffer += char;
-      i += 1;
-      continue;
-    }
-
-    if (state.markdownMode === 'bold') {
-      const close = state.markdownDelim === '__' ? (char === '_' && next === '_') : (char === '*' && next === '*');
-      if (close) {
+      if (char === '*' && next === '*') {
         out += paint(state.markdownBuffer, [ANSI.bold], options);
         state.markdownMode = 'normal';
         state.markdownBuffer = '';
-        state.markdownDelim = '';
         i += 2;
         continue;
       }
-      if ((char === '*' || char === '_') && next === undefined) {
-        state.markdownCarry = char;
-        break;
-      }
-      state.markdownBuffer += char;
-      i += 1;
-      continue;
-    }
-
-    if (state.markdownMode === 'italic') {
-      const close = char === state.markdownDelim && next !== state.markdownDelim;
-      if (close) {
-        out += paint(state.markdownBuffer, [ANSI.italic], options);
-        state.markdownMode = 'normal';
-        state.markdownBuffer = '';
-        state.markdownDelim = '';
-        i += 1;
-        continue;
-      }
-      if (char === state.markdownDelim && next === undefined) {
-        state.markdownCarry = char;
-        break;
-      }
-      state.markdownBuffer += char;
-      i += 1;
-      continue;
-    }
-
-    if (state.markdownMode === 'strike') {
-      if (char === '~' && next === '~') {
-        out += paint(state.markdownBuffer, [ANSI.strike], options);
-        state.markdownMode = 'normal';
-        state.markdownBuffer = '';
-        state.markdownDelim = '';
-        i += 2;
-        continue;
-      }
-      if (char === '~' && next === undefined) {
-        state.markdownCarry = '~';
-        break;
-      }
       state.markdownBuffer += char;
       i += 1;
       continue;
@@ -1476,19 +790,10 @@ function renderStreamingMarkdown(state, text, options = {}) {
 function flushStreamingMarkdown(state, output) {
   ensureMarkdownState(state);
   let out = state.markdownCarry || '';
-  state.markdownCarry = '';
-  if (state.markdownMode === 'bold_italic' && state.markdownBuffer) {
-    out += paint(state.markdownBuffer, [ANSI.bold, ANSI.italic], output);
-  } else if (state.markdownMode === 'bold' && state.markdownBuffer) {
+  if (state.markdownMode === 'bold' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.bold], output);
-  } else if (state.markdownMode === 'italic' && state.markdownBuffer) {
-    out += paint(state.markdownBuffer, [ANSI.italic], output);
-  } else if (state.markdownMode === 'strike' && state.markdownBuffer) {
-    out += paint(state.markdownBuffer, [ANSI.strike], output);
   } else if (state.markdownMode === 'code' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.accent], output);
-  } else if (state.markdownMode === 'fence' && state.markdownBuffer) {
-    out += renderFenceBuffer(state.markdownBuffer, output);
   }
   resetMarkdownState(state);
   if (out) output.write(out);
@@ -1538,26 +843,21 @@ 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 = 'Thinking';
+  let verb = 'Working';
   let interval = null;
   let timeout = null;
   let shown = false;
   let closed = false;
-  const renderOptions = () => ({
-    ...output,
-    color: options.color,
-    tick: frameIndex,
-    frameIndex,
-  });
 
   const render = () => {
     if (!enabled || closed) return;
     if (isTty) {
-      output.write(`\r${formatWorkingLine(Date.now() - startedAt, verb, renderOptions())}\x1b[K`);
-      frameIndex += 1;
+      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(`${formatWorkingLine(Date.now() - startedAt, verb, renderOptions())}\n`);
+      output.write(`${formatWorkingLine(Date.now() - startedAt)}\n`);
     }
     shown = true;
   };
@@ -1567,11 +867,11 @@ function createProgressReporter(output, options = {}) {
       if (!enabled) return;
       timeout = setTimeout(() => {
         render();
-        if (isTty) interval = setInterval(render, PROGRESS_FRAME_MS);
-      }, PROGRESS_START_DELAY_MS);
+        if (isTty) interval = setInterval(render, 120);
+      }, 700);
     },
     setVerb(next) {
-      verb = next || 'Thinking';
+      verb = next || 'Working';
     },
     clear() {
       if (!isTty || !shown || closed) return;
@@ -1588,17 +888,6 @@ function createProgressReporter(output, options = {}) {
   };
 }
 
-function manageTurnInterrupt(onInterrupt, options = {}) {
-  const trigger = () => onInterrupt();
-  const register = options.registerAbort;
-  if (typeof register === 'function') {
-    register(trigger);
-    return () => register(null);
-  }
-  process.once('SIGINT', trigger);
-  return () => process.removeListener('SIGINT', trigger);
-}
-
 function parseSseBlock(block) {
   const data = String(block || '')
     .split(/\r?\n/)
@@ -1695,6 +984,428 @@ function formatSystemInit(event, options = {}) {
   return parts.length ? parts.join('  ') : null;
 }
 
+function formatApprovalTime(value) {
+  const match = String(value || '').match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/);
+  if (!match) return '';
+  const [, year, month, day, rawHour, minute] = match;
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const hour24 = Number(rawHour);
+  const hour12 = hour24 % 12 || 12;
+  const ampm = hour24 >= 12 ? 'PM' : 'AM';
+  return `${months[Number(month) - 1] || month} ${Number(day)}, ${year} at ${hour12}:${minute} ${ampm}`;
+}
+
+function formatApprovalReceipt(receipt) {
+  if (!receipt || typeof receipt !== 'object') return null;
+  const events = Array.isArray(receipt.tool_events) ? receipt.tool_events : [];
+  const approvalEvent = events.find(event => event && event.approval_request);
+  const request = approvalEvent && approvalEvent.approval_request;
+  if (!request || request.status !== 'approval_required') return null;
+
+  const accept = receipt.task_accept_receipt || {};
+  const actionType = request.executor_action_type || request.action_type || '';
+  if (actionType === 'google_calendar_create_event' || accept.task === 'calendar.create_event') {
+    const payload = request.payload || {};
+    const start = accept.start || (payload.start && payload.start.dateTime) || (approvalEvent.preview && approvalEvent.preview.start);
+    const when = formatApprovalTime(start);
+    const title = taskPreviewTitle(receipt) || accept.title || (approvalEvent.preview && approvalEvent.preview.summary) || 'calendar event';
+    return `Approval needed before creation: calendar event "${String(title).slice(0, 80)}"${when ? ` ${when}` : ''}`;
+  }
+
+  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}`;
+}
+
+function taskPreviewApprovalEvent(receipt) {
+  const events = Array.isArray(receipt && receipt.tool_events) ? receipt.tool_events : [];
+  return events.find(event => event && event.approval_request) || null;
+}
+
+function taskPreviewTitle(receipt) {
+  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 accept = receipt && receipt.task_accept_receipt && typeof receipt.task_accept_receipt === 'object' ? receipt.task_accept_receipt : {};
+  const approvalEvent = taskPreviewApprovalEvent(receipt);
+  return String(
+    slots.title
+    || accept.title
+    || (approvalEvent && approvalEvent.preview && approvalEvent.preview.summary)
+    || ''
+  ).trim();
+}
+
+function formatTaskPreviewPlan(receipt) {
+  const taskPreview = receipt && receipt.task_preview && typeof receipt.task_preview === 'object' ? receipt.task_preview : null;
+  if (!taskPreview) return null;
+  const task = String(taskPreview.task || '').trim();
+  const slots = taskPreview.slots && typeof taskPreview.slots === 'object' ? taskPreview.slots : {};
+  if (task === 'calendar.create_event') {
+    const title = taskPreviewTitle(receipt);
+    const start = slots.start || (receipt.task_accept_receipt && receipt.task_accept_receipt.start);
+    const when = formatApprovalTime(start);
+    return ['create calendar event', title ? `"${title.slice(0, 80)}"` : '', when].filter(Boolean).join(' ');
+  }
+  return task ? task.replace(/[._-]/g, ' ') : null;
+}
+
+function formatTaskPreviewCheck(receipt) {
+  const taskPreview = receipt && receipt.task_preview && typeof receipt.task_preview === 'object' ? receipt.task_preview : null;
+  if (!taskPreview) return null;
+  const status = String(taskPreview.status || '').trim();
+  const missing = Array.isArray(taskPreview.missing)
+    ? taskPreview.missing.map(item => String(item || '').trim()).filter(Boolean)
+    : [];
+  if (missing.length) return `needs ${missing.join(', ')}`;
+  if (status === 'approval_required') return 'approval required';
+  if (status === 'needs_input') return 'needs input';
+  return status ? status.replace(/_/g, ' ') : null;
+}
+
+function formatTaskPreviewRows(receipt, options = {}) {
+  const taskPreview = receipt && receipt.task_preview && typeof receipt.task_preview === 'object' ? receipt.task_preview : null;
+  if (!taskPreview) return [];
+  const owner = String(taskPreview.owner_member || taskPreview.owner || '').trim();
+  const plan = formatTaskPreviewPlan(receipt);
+  const check = formatTaskPreviewCheck(receipt);
+  return [
+    owner ? formatAuxRow('owner', owner, options) : null,
+    plan ? formatAuxRow('plan', plan, options) : null,
+    check ? formatAuxRow('check', check, options) : null,
+  ].filter(Boolean);
+}
+
+function approvalStorePath(options = {}) {
+  return options.storePath || process.env.AX_APPROVAL_STORE || path.join(os.homedir(), '.atris', 'ax-approvals.json');
+}
+
+function approvalMaxAgeMs(options = {}) {
+  const value = Number(options.maxAgeMs);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_APPROVAL_MAX_AGE_MS;
+}
+
+function approvalRecordAgeMs(record, options = {}) {
+  const created = Date.parse(record && record.created_at ? record.created_at : '');
+  if (!Number.isFinite(created)) return Infinity;
+  const now = options.now instanceof Date ? options.now.getTime() : Number(options.now || Date.now());
+  return Math.max(0, now - created);
+}
+
+function storedApprovalIsStale(record, options = {}) {
+  return approvalRecordAgeMs(record, options) > approvalMaxAgeMs(options);
+}
+
+function emptyApprovalStore() {
+  return { schema: 'ax.pending_approvals.v1', approvals: [] };
+}
+
+function readApprovalStore(options = {}) {
+  const file = approvalStorePath(options);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const approvals = Array.isArray(parsed.approvals) ? parsed.approvals.filter(row => row && row.id && row.approval_request) : [];
+    return { schema: 'ax.pending_approvals.v1', approvals };
+  } catch (_) {
+    return emptyApprovalStore();
+  }
+}
+
+function writeApprovalStore(store, options = {}) {
+  const file = approvalStorePath(options);
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(dir, 0o700);
+  } catch (_) {}
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  const data = JSON.stringify({
+    schema: 'ax.pending_approvals.v1',
+    approvals: Array.isArray(store && store.approvals) ? store.approvals : [],
+  }, null, 2);
+  fs.writeFileSync(tmp, data, { mode: 0o600 });
+  fs.renameSync(tmp, file);
+  try {
+    fs.chmodSync(file, 0o600);
+  } catch (_) {}
+  return file;
+}
+
+function approvalRecordFromReceipt(receipt, approvalRequest, options = {}) {
+  const request = approvalRequestWithStableId(approvalRequest);
+  const id = request && (request.approval_request_id || request.approval_id);
+  if (!id) return null;
+  const approvalLine = formatApprovalReceipt({
+    ...receipt,
+    tool_events: [{
+      ...(taskPreviewApprovalEvent(receipt) || {}),
+      approval_request: request,
+    }],
+  });
+  return {
+    id,
+    created_at: options.createdAt || new Date().toISOString(),
+    updated_at: options.updatedAt || new Date().toISOString(),
+    cwd: options.cwd || '',
+    mode: normalizeMode(options.mode || 'fast'),
+    approval_request: request,
+    display_rows: [
+      ...formatTaskPreviewRows(receipt, { color: false }),
+      approvalLine ? formatAuxRow('wait', approvalLine, { color: false }) : null,
+    ].filter(Boolean),
+  };
+}
+
+function persistPendingApproval(receipt, approvalRequest, options = {}) {
+  if (options.disableApprovalStore) return null;
+  const record = approvalRecordFromReceipt(receipt || {}, approvalRequest, options);
+  if (!record) return null;
+  const store = readApprovalStore(options);
+  const existing = store.approvals.find(row => row.id === record.id);
+  if (existing && existing.created_at) record.created_at = existing.created_at;
+  store.approvals = [
+    record,
+    ...store.approvals.filter(row => row.id !== record.id),
+  ].slice(0, 50);
+  writeApprovalStore(store, options);
+  return record;
+}
+
+function findStoredApproval(ref, options = {}) {
+  const target = String(ref || '').trim();
+  if (!target) return null;
+  const store = readApprovalStore(options);
+  const matches = store.approvals.filter(row => String(row.id || '').startsWith(target));
+  if (matches.length !== 1) return null;
+  return matches[0];
+}
+
+function removeStoredApproval(ref, options = {}) {
+  const record = findStoredApproval(ref, options);
+  if (!record) return null;
+  const store = readApprovalStore(options);
+  store.approvals = store.approvals.filter(row => row.id !== record.id);
+  writeApprovalStore(store, options);
+  return record;
+}
+
+function formatStoredApprovals(store, options = {}) {
+  const approvals = Array.isArray(store && store.approvals) ? store.approvals : [];
+  if (!approvals.length) return 'No pending approvals.';
+  const blocks = ['Pending approvals'];
+  for (const approval of approvals) {
+    blocks.push(formatAuxRow('id', approval.id, options));
+    blocks.push(formatAuxRow('approve', formatApprovalCommand(approval.id), options));
+    for (const row of Array.isArray(approval.display_rows) ? approval.display_rows : []) {
+      blocks.push(row);
+    }
+  }
+  return blocks.join('\n');
+}
+
+function formatApprovalCommand(id) {
+  return `ax --approve ${String(id || '').trim()}`;
+}
+
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}
+
+function approvalRequestWithStableId(request) {
+  if (!request || typeof request !== 'object') return null;
+  const copy = JSON.parse(JSON.stringify(request));
+  if (!copy.approval_request_id && !copy.approval_id) {
+    const fingerprint = crypto
+      .createHash('sha256')
+      .update(stableStringify({
+        action_type: copy.executor_action_type || copy.action_type || copy.action || '',
+        connector: copy.connector || '',
+        payload: copy.payload || null,
+      }))
+      .digest('hex')
+      .slice(0, 20);
+    copy.approval_request_id = `apreq_ax_${fingerprint}`;
+  }
+  return copy;
+}
+
+function approvalRequestFromReceipt(receipt) {
+  if (!receipt || typeof receipt !== 'object') return null;
+  const events = Array.isArray(receipt.tool_events) ? receipt.tool_events : [];
+  const approvalEvent = events.find(event => event && event.approval_request);
+  const request = approvalEvent && approvalEvent.approval_request;
+  if (!request || request.status !== 'approval_required') return null;
+  return approvalRequestWithStableId(request);
+}
+
+function approvalExecutionRequestFromReceipt(receipt) {
+  if (!receipt || typeof receipt !== 'object') return null;
+  const accepted = receipt.task_accept_receipt || {};
+  if (accepted.accepted !== true) return null;
+  if (accepted.execution_endpoint && accepted.execution_endpoint !== APPROVAL_EXECUTE_PATH) return null;
+  if (accepted.execution_status && accepted.execution_status !== 'pending_approval_execution') return null;
+  return approvalRequestFromReceipt(receipt);
+}
+
+function approvalExecutionRequestFromState(state) {
+  return approvalExecutionRequestFromReceipt(receiptFromState(state));
+}
+
+function approvalActionLabel(actionType) {
+  if (actionType === 'google_calendar_create_event') return 'calendar event';
+  if (actionType === 'gmail_send') return 'email';
+  if (actionType === 'slack_post_message') return 'Slack message';
+  if (actionType === 'github_create_issue') return 'GitHub issue';
+  if (actionType === 'google_drive_create_file') return 'Drive file';
+  if (actionType === 'notion_create_page') return 'Notion page';
+  return 'approved action';
+}
+
+function capitalize(value) {
+  const text = String(value || '');
+  return text ? `${text[0].toUpperCase()}${text.slice(1)}` : text;
+}
+
+function approvalSuccessMessage(actionType) {
+  const actionLabel = approvalActionLabel(actionType);
+  if (actionType === 'gmail_send') return 'Sent email.';
+  if (actionType === 'slack_post_message') return 'Sent Slack message.';
+  return `Created ${actionLabel}.`;
+}
+
+function approvalNotDoneMessage(actionType, reason) {
+  const actionLabel = approvalActionLabel(actionType);
+  const verb = actionType === 'gmail_send' || actionType === 'slack_post_message' ? 'sent' : 'created';
+  return `${capitalize(actionLabel)} was not ${verb} because ${reason}.`;
+}
+
+function formatApprovalExecutionResult(response) {
+  if (!response) return null;
+  const data = response.data && typeof response.data === 'object' ? response.data : {};
+  const detail = data.detail && typeof data.detail === 'object' ? data.detail : {};
+  const execution = data.execution && typeof data.execution === 'object' ? data.execution : {};
+  const actionType = data.action_type || execution.action_type || detail.action_type || '';
+  const actionLabel = approvalActionLabel(actionType);
+  const status = data.status || execution.status || detail.error || '';
+
+  if (!response.ok) {
+    if (detail.error === 'paid_cloud_computer_required') return 'Approval execution needs a paid cloud computer.';
+    if (detail.error === 'approval_signing_key_required') return 'Approval execution is not configured in this runtime.';
+    if (detail.error === 'approval_already_executed') return `Already executed this ${actionLabel}.`;
+    if (detail.user_message) return String(detail.user_message);
+    if (detail.message) return String(detail.message);
+    return response.error || `Approval execution failed (${response.status || 'unknown'}).`;
+  }
+
+  if (execution.executed || status === 'executed') return approvalSuccessMessage(actionType);
+  if (status === 'blocked_connector_not_connected') return approvalNotDoneMessage(actionType, 'the connector is not connected');
+  if (status === 'execution_failed') return approvalNotDoneMessage(actionType, 'execution failed');
+  if (execution.would_execute) return `${actionLabel[0].toUpperCase()}${actionLabel.slice(1)} was approved but not confirmed as created.`;
+  return `Approval handled for ${actionLabel}.`;
+}
+
+function approvalExecutionShouldRemainPending(response) {
+  if (!response) return true;
+  const data = response.data && typeof response.data === 'object' ? response.data : {};
+  const detail = data.detail && typeof data.detail === 'object' ? data.detail : {};
+  const execution = data.execution && typeof data.execution === 'object' ? data.execution : {};
+  const status = data.status || execution.status || detail.error || '';
+  if (execution.executed || status === 'executed') return false;
+  if (detail.error === 'approval_already_executed') return false;
+  return true;
+}
+
+function creditsFromApprovalExecution(response) {
+  const billing = response && response.data && response.data.billing;
+  if (!billing || billing.billed === false) return null;
+  const credits = Number(billing.credits_charged);
+  return Number.isFinite(credits) && credits > 0 ? credits : null;
+}
+
+async function postApprovalExecution(approvalRequest, { model = 'atris:fast', token = authToken() } = {}) {
+  return postJson(APPROVAL_EXECUTE_PATH, {
+    model,
+    approval_request: approvalRequest,
+  }, { token });
+}
+
+async function executeApprovalRequest(approvalRequest, {
+  model = 'atris:fast',
+  output = process.stdout,
+  postApproval = postApprovalExecution,
+  state = null,
+} = {}) {
+  if (!approvalRequest) return null;
+  const localState = state || {
+    events: [],
+    errors: [],
+    output: '',
+    pendingText: '',
+    wroteText: false,
+    wroteActivity: false,
+    lastChar: '\n',
+    progress: null,
+    inAuxBlock: false,
+    needsBullet: true,
+  };
+  writeAuxLine(localState, output, formatAuxRow('wait', 'Sending approved action to Atris cloud...', output));
+  const response = await postApproval(approvalRequest, { model });
+  const message = formatApprovalExecutionResult(response);
+  if (message) {
+    const execution = response && response.data && response.data.execution;
+    const label = response && response.ok && execution && execution.executed ? 'done' : 'wait';
+    writeAuxLine(localState, output, formatAuxRow(label, message, output));
+  }
+  return { approval_request: approvalRequest, response, message };
+}
+
+async function executeApprovalFromState(state, options = {}) {
+  const approvalRequest = approvalExecutionRequestFromState(state);
+  if (!approvalRequest) return null;
+  return executeApprovalRequest(approvalRequest, { ...options, state });
+}
+
+async function approveStoredApproval(ref, options = {}) {
+  const record = findStoredApproval(ref, options);
+  if (!record) throw new Error(`Pending approval not found: ${ref}`);
+  const output = options.output || process.stdout;
+  const startedAt = Date.now();
+  output.write(`${formatAuxRow('id', record.id, output)}\n`);
+  for (const row of Array.isArray(record.display_rows) ? record.display_rows : []) {
+    output.write(`${row}\n`);
+  }
+  if (storedApprovalIsStale(record, options)) {
+    removeStoredApproval(record.id, options);
+    const message = 'Approval expired. Recreate the preview before approving.';
+    output.write(`${formatAuxRow('wait', message, output)}\n`);
+    output.write(`${formatDoneLine(Date.now() - startedAt)}\n`);
+    return { approval_request: record.approval_request, response: null, message, stale: true };
+  }
+  output.write('Accepted.\n');
+  const execution = await executeApprovalRequest(record.approval_request, {
+    model: options.model || modelForMode(options.mode || record.mode || 'fast'),
+    output,
+    ...(options.postApproval ? { postApproval: options.postApproval } : {}),
+  });
+  const credits = creditsFromApprovalExecution(execution && execution.response);
+  output.write(`${formatDoneLine(Date.now() - startedAt, credits)}\n`);
+  if (approvalExecutionShouldRemainPending(execution && execution.response)) {
+    const store = readApprovalStore(options);
+    store.approvals = store.approvals.map(row => row.id === record.id ? { ...row, updated_at: new Date().toISOString() } : row);
+    writeApprovalStore(store, options);
+  } else {
+    removeStoredApproval(record.id, options);
+  }
+  return execution;
+}
+
+function denyStoredApproval(ref, options = {}) {
+  const record = removeStoredApproval(ref, options);
+  if (!record) throw new Error(`Pending approval not found: ${ref}`);
+  return record;
+}
+
 function clearRetriedText(state) {
   state.pendingText = '';
   state.output = '';
@@ -1712,7 +1423,7 @@ function stopProgress(state) {
 }
 
 function flushPendingText(state, output) {
-  const hasMarkdownRemainder = output && (
+  const hasMarkdownRemainder = output && output.isTTY && (
     state.markdownCarry
     || state.markdownBuffer
     || (state.markdownMode && state.markdownMode !== 'normal')
@@ -1724,7 +1435,7 @@ function flushPendingText(state, output) {
     output.write('● ');
     state.needsBullet = false;
   }
-  if (state.pendingText) output.write(renderTerminalMarkdown(state.pendingText, output));
+  if (state.pendingText) output.write(output && output.isTTY ? renderTerminalMarkdown(state.pendingText, output) : state.pendingText);
   const flushedMarkdown = hasMarkdownRemainder ? flushStreamingMarkdown(state, output) : '';
   state.wroteText = true;
   state.wroteActivity = true;
@@ -1763,42 +1474,92 @@ function writeAuxLine(state, output, line) {
   state.needsBullet = true;
 }
 
-function compactHistory(history, limit = 8) {
-  return history
+function structuredHistory(history, limit = 8) {
+  return (Array.isArray(history) ? history : [])
     .slice(-limit)
-    .map(turn => `${turn.role}: ${String(turn.content || '').slice(0, 1200)}`)
-    .join('\n');
+    .map(turn => {
+      const message = {
+        role: turn && turn.role === 'assistant' ? 'assistant' : 'user',
+        content: String((turn && turn.content) || '').slice(0, 1200)
+      };
+      if (message.role === 'assistant' && turn && turn.task_preview) {
+        message.task_preview = turn.task_preview;
+      }
+      return message;
+    })
+    .filter(turn => turn.content.trim());
+}
+
+function latestPendingTaskPreview(history = []) {
+  for (const turn of [...(Array.isArray(history) ? history : [])].reverse()) {
+    if (!turn || turn.role !== 'assistant' || !turn.task_preview) continue;
+    const status = String(turn.task_preview.status || '');
+    if (['needs_input', 'approval_required'].includes(status)) return turn.task_preview;
+    return null;
+  }
+  return null;
+}
+
+function latestPendingApprovalRequest(history = []) {
+  for (const turn of [...(Array.isArray(history) ? history : [])].reverse()) {
+    if (!turn || turn.role !== 'assistant') continue;
+    if (turn.approval_request) return approvalRequestWithStableId(turn.approval_request);
+    return null;
+  }
+  return null;
+}
+
+function messageApprovesPendingApproval(message) {
+  const normalized = String(message || '').trim().toLowerCase().replace(/[.!?]+$/g, '');
+  return new Set([
+    'yes',
+    'y',
+    'yep',
+    'yeah',
+    'ok',
+    'okay',
+    'approve',
+    'approved',
+    'confirm',
+    'create it',
+    'send it',
+    'post it',
+    'do it',
+    'go ahead',
+    'looks good',
+    'yes create it',
+    'yes send it',
+    'yes post it',
+  ]).has(normalized);
+}
+
+function messageCancelsPendingApproval(message) {
+  const normalized = String(message || '').trim().toLowerCase().replace(/[.!?]+$/g, '');
+  return new Set(['no', 'nope', 'cancel', 'cancel it', 'stop', 'never mind', 'nevermind', 'do not', "don't"]).has(normalized);
 }
 
 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');
+  return String(message || '').trim();
 }
 
 function buildPayload(message, options = {}) {
   const mode = normalizeMode(options.mode);
   const route = options.business ? 'local' : resolveRoute(message, options);
   const local = route !== 'cloud';
-  const bypass = resolveBypassPermissions(options);
   const verifyCommand = String(options.verify || '').trim();
+  const previousMessages = structuredHistory(options.history || []);
   const payload = {
     message: buildMessage(message, options.history || []),
     model: modelForMode(mode),
-    max_turns: options.goalEval ? 1 : (local ? (mode === 'fast' ? 8 : 14) : 1),
-    verify_command: verifyCommand || 'true',
-    member_slug: MEMBER_SLUG,
-    bypass_permissions: bypass,
+    max_turns: local ? (mode === 'fast' ? 8 : 14) : 1,
+    verify_command: verifyCommand || 'true'
   };
+  if (previousMessages.length) {
+    payload.previous_messages = previousMessages;
+  }
+  if (options.conversationId) {
+    payload.conversation_id = String(options.conversationId);
+  }
   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
@@ -1814,20 +1575,22 @@ function buildPayload(message, options = {}) {
   if (!local && options.connectionUserId) {
     payload.connection_user_id = options.connectionUserId;
   }
-  if (!local && bypass && connectorWriteIntent(message)) {
-    payload.allow_external_actions = true;
-    payload.cleanup_external_actions = true;
-    payload.max_turns = mode === 'fast' ? 2 : 4;
-  }
   return payload;
 }
 
 function buildCodeFastPayload(message, options = {}) {
+  const previousMessages = structuredHistory(options.history || []);
   const payload = {
     message: buildMessage(message, options.history || []),
     model: CODE_FAST.model,
     timeout_seconds: Number(options.timeoutSeconds || 180)
   };
+  if (previousMessages.length) {
+    payload.previous_messages = previousMessages;
+  }
+  if (options.conversationId) {
+    payload.conversation_id = String(options.conversationId);
+  }
   if (isCodeFastLocal(options)) {
     payload.workspace_path = options.cwd || process.cwd();
   }
@@ -1880,7 +1643,6 @@ function handleEvent(event, state, output) {
       writeAuxLine(state, output, formatToolResultLine(summarizeToolResult(result, output), output));
       state.lastAux = 'result';
     }
-    if (state.progress && state.progress.setVerb) state.progress.setVerb('Thinking');
     return;
   }
 
@@ -1911,13 +1673,23 @@ function handleEvent(event, state, output) {
       clearRetriedText(state);
       return;
     }
-    if (state.progress && state.progress.setVerb && /think|reason|plan/i.test(event.message)) {
-      state.progress.setVerb('Thinking');
-    }
     flushPendingText(state, output);
-    const statusText = formatStatusMessage(event.message);
-    if (statusText) {
-      writeAuxLine(state, output, paint(`✦ ${statusText}`, [ANSI.bold, ANSI.magenta], output));
+    writeAuxLine(state, output, paint(`· ${formatStatusMessage(event.message)}`, [ANSI.muted], output));
+    return;
+  }
+
+  if (event.type === 'receipt' && event.receipt) {
+    const approvalLine = formatApprovalReceipt(event.receipt);
+    const previewRows = formatTaskPreviewRows(event.receipt, output);
+    if (approvalLine) {
+      flushPendingText(state, output);
+      for (const row of previewRows) writeAuxLine(state, output, row);
+      writeAuxLine(state, output, formatAuxRow('wait', approvalLine, output));
+      state.lastAux = 'approval';
+    } else if (previewRows.length) {
+      flushPendingText(state, output);
+      for (const row of previewRows) writeAuxLine(state, output, row);
+      state.lastAux = 'preview';
     }
     return;
   }
@@ -1946,7 +1718,7 @@ async function postTurn(message, options = {}) {
   const connectionContext = options.connectionContext || (shouldSendConnectionContext
     ? await buildConnectionContext({ token, localWorkspace: local })
     : null);
-  const connectionUserId = !local && isLoopbackBackend({ route }) ? authUserId() : '';
+  const connectionUserId = !local && isLoopbackBackend() ? authUserId() : '';
   const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
@@ -1954,7 +1726,7 @@ async function postTurn(message, options = {}) {
   // 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());
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
     events: [],
@@ -1972,19 +1744,15 @@ async function postTurn(message, options = {}) {
     markdownMode: 'normal',
     markdownBuffer: '',
     markdownCarry: '',
-    atLineStart: true,
     relay: options.business ? {
       chain: Promise.resolve(),
       execute: options.business.executor,
-      post: (callId, result) => options.business.postToolResult(callId, result, backendBaseUrl({ route }))
+      post: (callId, result) => options.business.postToolResult(callId, result, backendBaseUrl())
     } : null
   };
 
   return new Promise((resolve, reject) => {
     let settled = false;
-    let interrupted = false;
-    let req = null;
-    let removeInterrupt = null;
     const startedAt = Date.now();
     state.progress = createProgressReporter(output, options);
     state.progress.start();
@@ -1992,8 +1760,6 @@ async function postTurn(message, options = {}) {
     const finish = (error, value) => {
       if (settled) return;
       settled = true;
-      if (removeInterrupt) removeInterrupt();
-      removeInterrupt = null;
       if (state.progress) state.progress.stop();
       state.progress = null;
       state.durationMs = Date.now() - startedAt;
@@ -2001,15 +1767,7 @@ async function postTurn(message, options = {}) {
       else resolve(value);
     };
 
-    removeInterrupt = manageTurnInterrupt(() => {
-      if (settled) return;
-      interrupted = true;
-      flushPendingText(state, output);
-      if (req) req.destroy();
-      finish(null, { ...state, interrupted: true });
-    }, options);
-
-    req = transport.request({
+    const req = transport.request({
       hostname: turnUrl.hostname,
       port: turnUrl.port || (turnUrl.protocol === 'https:' ? 443 : 80),
       path: `${turnUrl.pathname}${turnUrl.search}`,
@@ -2074,12 +1832,8 @@ async function postTurn(message, options = {}) {
       });
     });
 
-    req.on('error', (error) => {
-      if (interrupted) return;
-      finish(error);
-    });
+    req.on('error', finish);
     req.setTimeout(timeoutMs, () => {
-      if (settled) return;
       finish(new Error(`Request timeout after ${timeoutMs / 1000}s`));
       req.destroy();
     });
@@ -2099,7 +1853,7 @@ async function postCodeFastTurn(message, options = {}) {
   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({ ...options, route }));
+  const turnUrl = new URL(codeFastUrl());
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
     events: [],
@@ -2116,15 +1870,11 @@ async function postCodeFastTurn(message, options = {}) {
     lastAux: '',
     markdownMode: 'normal',
     markdownBuffer: '',
-    markdownCarry: '',
-    atLineStart: true,
+    markdownCarry: ''
   };
 
   return new Promise((resolve, reject) => {
     let settled = false;
-    let interrupted = false;
-    let req = null;
-    let removeInterrupt = null;
     const startedAt = Date.now();
     state.progress = createProgressReporter(output, options);
     state.progress.start();
@@ -2132,8 +1882,6 @@ async function postCodeFastTurn(message, options = {}) {
     const finish = (error, value) => {
       if (settled) return;
       settled = true;
-      if (removeInterrupt) removeInterrupt();
-      removeInterrupt = null;
       if (state.progress) state.progress.stop();
       state.progress = null;
       state.durationMs = Date.now() - startedAt;
@@ -2141,15 +1889,7 @@ async function postCodeFastTurn(message, options = {}) {
       else resolve(value);
     };
 
-    removeInterrupt = manageTurnInterrupt(() => {
-      if (settled) return;
-      interrupted = true;
-      flushPendingText(state, output);
-      if (req) req.destroy();
-      finish(null, { ...state, interrupted: true });
-    }, options);
-
-    req = transport.request({
+    const req = transport.request({
       hostname: turnUrl.hostname,
       port: turnUrl.port || (turnUrl.protocol === 'https:' ? 443 : 80),
       path: `${turnUrl.pathname}${turnUrl.search}`,
@@ -2201,12 +1941,8 @@ async function postCodeFastTurn(message, options = {}) {
       });
     });
 
-    req.on('error', (error) => {
-      if (interrupted) return;
-      finish(error);
-    });
+    req.on('error', finish);
     req.setTimeout(timeoutMs, () => {
-      if (settled) return;
       finish(new Error(`Request timeout after ${timeoutMs / 1000}s`));
       req.destroy();
     });
@@ -2221,136 +1957,36 @@ function turnFunctionForMode(mode) {
 
 async function chat(options = {}) {
   let mode = normalizeMode(options.mode);
-  let bypassPermissions = resolveBypassPermissions(options);
   const cwd = options.cwd || process.cwd();
   const input = options.input || process.stdin;
   const baseOutput = options.output || process.stdout;
   const logger = createRunLogger({ cwd, mode, kind: 'play', output: baseOutput });
   const output = logger ? logger.output : baseOutput;
   const history = [];
-  let goalState = null;
-  let lastAchievedGoal = null;
-
-  const goalPaintOptions = {
-    paint: (text, codes) => paint(text, codes, output),
-    bold: ANSI.bold,
-    magenta: ANSI.magenta,
-    muted: ANSI.muted,
-    accent: ANSI.accent,
-    ok: ANSI.ok,
-  };
+  const conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
 
-  const writeHeader = () => {
-    output.write(`${formatHeader({ mode, cwd, chat: true, bypassPermissions, goal: goalState }, output)}\n\n`);
-  };
-
-  writeHeader();
-
-  const executeChatTurn = async (message, turnOptions = {}) => {
-    let result;
-    try {
-      const turnFn = typeof options.turnFunction === 'function'
-        ? options.turnFunction
-        : turnFunctionForMode(mode);
-      result = await turnFn(message, {
-        mode,
-        cwd,
-        history,
-        output,
-        route: options.route,
-        business: options.business,
-        verify: options.verify,
-        bypassPermissions,
-        registerAbort: options.registerAbort,
-        goalEval: turnOptions.goalEval === true,
-      });
-    } finally {
-      if (typeof options.registerAbort === 'function') options.registerAbort(null);
-    }
+  output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
+  if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
 
-    if (result.interrupted) {
-      if (result.output && !result.output.endsWith('\n')) output.write('\n');
-      if (!turnOptions.goalEval) {
-        output.write(`${paint('· Interrupted', [ANSI.muted], output)}\n\n`);
-      }
-      if (result.output && result.output.trim()) {
-        history.push({ role: 'user', content: message });
-        history.push({ role: 'assistant', content: result.output });
-      }
-      return result;
-    }
-
-    if (result.output && !result.output.endsWith('\n')) output.write('\n');
-    if (!turnOptions.goalEval) {
-      output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n\n`);
+  const runtimePreflight = { ready: false };
+  const ensureRuntimeReady = async () => {
+    if (runtimePreflight.ready) return true;
+    if (options.skipRuntimePreflight || options.turnFunction || options.business || normalizeMode(mode) === 'code-fast') {
+      runtimePreflight.ready = true;
+      return true;
     }
-    history.push({ role: 'user', content: message });
-    history.push({ role: 'assistant', content: result.output || '' });
-    return result;
-  };
-
-  const runGoalLoop = async (activeGoal) => {
-    output.write(`${formatGoalStatus(activeGoal, goalPaintOptions)}\n\n`);
-    writeHeader();
-
-    while (activeGoal.active) {
-      const directive = buildGoalDirective(activeGoal, { continue: activeGoal.turns > 0 });
-      if (activeGoal.turns > 0) {
-        output.write(`${formatGoalContinue(activeGoal, goalPaintOptions)}\n\n`);
-      }
-      output.write('\n');
-
-      const result = await executeChatTurn(directive, { goalLoop: true });
-      activeGoal.turns += 1;
-      accumulateGoalUsage(activeGoal, result, creditsFromState);
-
-      if (result.interrupted) {
-        output.write(`${paint('· Goal turn interrupted — /goal for status · /goal clear to stop', [ANSI.muted], output)}\n\n`);
-        return;
-      }
-
-      const evalResult = await evaluateGoalTurn(activeGoal, {
-        history,
-        lastOutput: result.output,
-        turnOptions: {
-          mode,
-          cwd,
-          bypassPermissions,
-          route: options.route,
-          business: options.business,
-          verify: options.verify,
-          registerAbort: options.registerAbort,
-        },
-      }, { postTurn, evaluateGoal: options.evaluateGoal });
-
-      activeGoal.evalTurns += 1;
-      activeGoal.lastReason = evalResult.reason || activeGoal.lastReason;
-
-      if (evalResult.achieved) {
-        finishGoalAchieved(activeGoal, evalResult.reason);
-        output.write(`${formatGoalAchieved(activeGoal, goalPaintOptions)}\n\n`);
-        lastAchievedGoal = { ...activeGoal };
-        goalState = null;
-        writeHeader();
-        return;
-      }
-
-      if (goalTurnLimitReached(activeGoal)) {
-        clearGoalState(activeGoal);
-        output.write(`${formatGoalStopped(activeGoal, 'Turn limit reached.', goalPaintOptions)}\n\n`);
-        goalState = null;
-        writeHeader();
-        return;
-      }
-
-      if (goalBudgetExceeded(activeGoal)) {
-        clearGoalState(activeGoal);
-        output.write(`${formatGoalStopped(activeGoal, 'Token budget reached.', goalPaintOptions)}\n\n`);
-        goalState = null;
-        writeHeader();
-        return;
-      }
+    const startedAt = Date.now();
+    const health = options.runtimeHealth
+      ? await Promise.resolve(options.runtimeHealth({ mode }))
+      : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200 });
+    if (runtimeReadyForChat(health, mode)) {
+      runtimePreflight.ready = true;
+      return true;
     }
+    output.write(`${formatRuntimeHealth(health, output)}\n\n`);
+    output.write(`${formatBackendHint()}\n`);
+    output.write(`${formatDoneLine(Date.now() - startedAt)}\n\n`);
+    return false;
   };
 
   const runLine = async (line) => {
@@ -2371,68 +2007,104 @@ async function chat(options = {}) {
       return false;
     }
 
-    const permission = chatPermissionCommand(trimmed);
-    if (permission !== null) {
-      bypassPermissions = permission;
-      const persistPrefs = options.persistPrefs !== false;
-      setBypassPermissions(permission, { persist: persistPrefs });
-      if (logger) logger.write(`${trimmed}\n`);
-      output.write(`${formatPermissionToggleMessage(permission, { ...output, persistPrefs })}\n\n`);
-      return false;
-    }
-
-    const goalCmd = parseGoalCommand(trimmed);
-    if (goalCmd) {
-      if (logger) logger.write(`${trimmed}\n`);
-      if (goalCmd.action === 'clear') {
-        if (goalState) clearGoalState(goalState);
-        goalState = null;
-        output.write(`${paint('· Goal cleared', [ANSI.ok], output)}\n\n`);
-        writeHeader();
-        return false;
-      }
-      if (goalCmd.action === 'status') {
-        output.write(`${formatGoalStatus(goalState || lastAchievedGoal, goalPaintOptions)}\n\n`);
-        return false;
-      }
-      if (goalCmd.action === 'set') {
-        if (goalState && goalState.active) clearGoalState(goalState);
-        goalState = createGoalState(goalCmd.condition, goalCmd);
-        lastAchievedGoal = null;
-        await runGoalLoop(goalState);
-        return false;
-      }
-    }
-
     if (trimmed.startsWith('/')) {
       output.write(`${chatMenu(output)}\n\n`);
       return false;
     }
 
-    if (extractYoutubeUrl(trimmed)) {
-      if (logger) logger.write(`${formatPrompt(mode, { ...output, goal: goalState })}${trimmed}\n`);
-      output.write('\n');
+    if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
+    output.write('\n');
+    const pendingApprovalRequest = latestPendingApprovalRequest(history);
+    if (pendingApprovalRequest && normalizeMode(mode) !== 'code-fast' && messageCancelsPendingApproval(trimmed)) {
       const startedAt = Date.now();
-      const youtubeOutput = [];
-      await runAxYoutubeCommand([trimmed], {
-        youtubeCommand: options.youtubeCommand,
-        ensureValidCredentials: options.ensureValidCredentials,
-        apiRequestJson: options.apiRequestJson,
-        output: (line = '') => {
-          const text = String(line);
-          youtubeOutput.push(text);
-          output.write(`${text}\n`);
-        },
-      });
+      if (!options.turnFunction) removeStoredApproval(pendingApprovalRequest.approval_request_id || pendingApprovalRequest.approval_id, { storePath: options.approvalStorePath });
+      output.write('Cancelled.\n');
       output.write(`${formatDoneLine(Date.now() - startedAt)}\n\n`);
       history.push({ role: 'user', content: trimmed });
-      history.push({ role: 'assistant', content: youtubeOutput.join('\n') });
+      history.push({ role: 'assistant', content: 'Cancelled.' });
+      return false;
+    }
+    if (pendingApprovalRequest && normalizeMode(mode) !== 'code-fast' && messageApprovesPendingApproval(trimmed)) {
+      if (!(await ensureRuntimeReady())) return false;
+      const startedAt = Date.now();
+      const approvalState = {
+        events: [],
+        errors: [],
+        output: 'Accepted.',
+        pendingText: '',
+        wroteText: true,
+        wroteActivity: true,
+        lastChar: '\n',
+        progress: null,
+        inAuxBlock: false,
+        needsBullet: true,
+      };
+      output.write('Accepted.\n');
+      const approvalExecution = await executeApprovalRequest(pendingApprovalRequest, {
+        model: modelForMode(mode),
+        output,
+        state: approvalState,
+        ...(options.postApproval ? { postApproval: options.postApproval } : {}),
+      });
+      const credits = creditsFromApprovalExecution(approvalExecution && approvalExecution.response);
+      output.write(`${formatDoneLine(Date.now() - startedAt, credits)}\n\n`);
+      if (!options.turnFunction) {
+        const approvalId = pendingApprovalRequest.approval_request_id || pendingApprovalRequest.approval_id;
+        if (approvalExecutionShouldRemainPending(approvalExecution && approvalExecution.response)) {
+          persistPendingApproval({}, pendingApprovalRequest, { cwd, mode, storePath: options.approvalStorePath });
+        } else {
+          removeStoredApproval(approvalId, { storePath: options.approvalStorePath });
+        }
+      }
+      history.push({ role: 'user', content: trimmed });
+      history.push({
+        role: 'assistant',
+        content: ['Accepted.', approvalExecution && approvalExecution.message ? approvalExecution.message : ''].filter(Boolean).join('\n'),
+        ...(
+          approvalExecutionShouldRemainPending(approvalExecution && approvalExecution.response)
+            ? { approval_request: pendingApprovalRequest }
+            : {}
+        ),
+      });
       return false;
     }
 
-    if (logger) logger.write(`${formatPrompt(mode, { ...output, goal: goalState })}${trimmed}\n`);
-    output.write('\n');
-    await executeChatTurn(trimmed);
+    const pendingTaskPreview = latestPendingTaskPreview(history);
+    const route = pendingTaskPreview ? 'cloud' : options.route;
+    if (!(await ensureRuntimeReady())) 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 });
+    if (result.output && !result.output.endsWith('\n')) output.write('\n');
+    const approvalExecution = normalizeMode(mode) === 'code-fast'
+      ? null
+      : await executeApprovalFromState(result, {
+        model: modelForMode(mode),
+        output,
+        ...(options.postApproval ? { postApproval: options.postApproval } : {}),
+      });
+    output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n\n`);
+    const receipt = receiptFromState(result);
+    const approvalRequest = approvalExecution
+      ? (
+          approvalExecutionShouldRemainPending(approvalExecution.response)
+            ? approvalExecution.approval_request
+            : null
+        )
+      : approvalRequestFromReceipt(receipt);
+    if (approvalRequest && !options.turnFunction) {
+      persistPendingApproval(receipt, approvalRequest, { cwd, mode, storePath: options.approvalStorePath });
+    }
+    const assistantContent = [
+      result.output || '',
+      approvalExecution && approvalExecution.message ? approvalExecution.message : '',
+    ].filter(Boolean).join('\n');
+    history.push({ role: 'user', content: trimmed });
+    history.push({
+      role: 'assistant',
+      content: assistantContent,
+      ...(receipt && receipt.task_preview ? { task_preview: receipt.task_preview } : {}),
+      ...(approvalRequest ? { approval_request: approvalRequest } : {}),
+    });
     return false;
   };
 
@@ -2445,445 +2117,29 @@ async function chat(options = {}) {
     return;
   }
 
-  const rl = readline.createInterface({
-    input,
-    output: baseOutput,
-    completer: chatCompleter,
-    crlfDelay: Infinity,
-  });
-  readline.emitKeypressEvents(input, rl);
-  // Bracketed paste: terminals wrap pasted text in \x1b[200~ … \x1b[201~ so a
-  // multi-line paste lands as ONE message instead of submitting on every
-  // newline. readline + the multiline hook already understand the markers; we
-  // just have to turn the mode on (and off again on every exit path).
-  const setBracketedPaste = (on) => {
-    if (baseOutput && baseOutput.isTTY && typeof baseOutput.write === 'function') {
-      baseOutput.write(on ? '\x1b[?2004h' : '\x1b[?2004l');
-    }
-  };
-  const disableBracketedPasteOnExit = () => setBracketedPaste(false);
-  setBracketedPaste(true);
-  process.once('exit', disableBracketedPasteOnExit);
-  // readline can't emit a 'line' string that holds a literal newline, so the
-  // multiline hook hands us the true buffer here and ask() prefers it.
-  let pendingMultilineLine = null;
-  const detachMultilineInput = attachMultilineChatInput(rl, {
-    insertBreak: insertMultilineBreak,
-    onSubmit: (line) => { pendingMultilineLine = line; },
-  });
-  const boxLayoutOptions = () => inputBoxLayoutOptions(baseOutput, { bypassPermissions });
-  let exiting = false;
-  let awaitingInput = false;
-  // Repaint the box bottom rule after every readline render so the frame stays
-  // closed while typing (empty, wrapped, and multiline input alike).
-  const baseRefreshLine = typeof rl._refreshLine === 'function' ? rl._refreshLine.bind(rl) : null;
-  if (baseRefreshLine) {
-    rl._refreshLine = () => {
-      baseRefreshLine();
-      if (awaitingInput) repaintInputBoxBottom(rl, baseOutput, boxLayoutOptions());
-    };
-  }
-  let turnAbort = null;
-  options.registerAbort = (fn) => {
-    turnAbort = typeof fn === 'function' ? fn : null;
-  };
-  const onChatKeypress = (_str, key) => {
-    if (!awaitingInput) return;
-    if (!isPermissionToggleKey(key)) return;
-    bypassPermissions = !bypassPermissions;
-    const persistPrefs = options.persistPrefs !== false;
-    setBypassPermissions(bypassPermissions, { persist: persistPrefs });
-    if (logger) logger.write(`[shift+tab permissions ${bypassPermissions ? 'bypass' : 'safe'}]\n`);
-    // The mode label lives on the status line below the box now, so repaint
-    // that (it also restores the cursor) instead of redrawing the plain top.
-    repaintInputBoxBottom(rl, baseOutput, boxLayoutOptions());
-  };
-  input.prependListener('keypress', onChatKeypress);
-  rl.on('SIGINT', () => {
-    if (turnAbort) {
-      turnAbort();
-      return;
-    }
-    exiting = true;
-    output.write('\n');
-    rl.close();
-  });
-  const ask = () => new Promise((resolve, reject) => {
-    function onClose() {
-      reject(new Error('CHAT_CLOSED'));
-    }
-    rl.once('close', onClose);
-    awaitingInput = true;
-    const layout = boxLayoutOptions();
-    output.write(`\n${formatInputBoxTop(layout)}\n`);
-    pendingMultilineLine = null;
-    rl.question(formatChatInputPrompt(mode, { ...layout, goal: goalState }), (answer) => {
-      awaitingInput = false;
-      rl.removeListener('close', onClose);
-      closeInputBox(output, layout);
-      const captured = pendingMultilineLine;
-      pendingMultilineLine = null;
-      resolve(stripMultilineCsiText(captured != null ? captured : answer));
-    });
-  });
-  while (!exiting) {
-    let line = '';
-    try {
-      line = await ask();
-    } catch (error) {
-      if (error && error.message === 'CHAT_CLOSED') break;
-      throw error;
-    }
+  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)) {
       rl.close();
       break;
     }
   }
-  input.removeListener('keypress', onChatKeypress);
-  detachMultilineInput();
-  if (baseRefreshLine) rl._refreshLine = baseRefreshLine;
-  setBracketedPaste(false);
-  process.removeListener('exit', disableBracketedPasteOnExit);
   if (logger) logger.close(0);
 }
 
-function newestAxLog(cwd, sinceMs = 0) {
-  const runsDir = path.join(cwd, 'atris', 'runs');
-  if (!fs.existsSync(runsDir)) return null;
-  let newest = null;
-  for (const name of fs.readdirSync(runsDir)) {
-    if (!/^ax-.*\.log$/.test(name)) continue;
-    const full = path.join(runsDir, name);
-    let stat = null;
-    try {
-      stat = fs.statSync(full);
-    } catch {
-      continue;
-    }
-    if (!stat.isFile() || stat.mtimeMs < sinceMs) continue;
-    if (!newest || stat.mtimeMs > newest.mtimeMs) newest = { path: full, mtimeMs: stat.mtimeMs };
-  }
-  return newest ? newest.path : null;
-}
-
-function makeChecklistItem(id, label, passed, evidence = '') {
-  return { id, label, passed: passed === true, evidence: compactText(evidence, 180) };
-}
-
-function compactText(text, max = 180) {
-  const one = String(text || '').replace(/\s+/g, ' ').trim();
-  if (!one) return '';
-  return one.length <= max ? one : `${one.slice(0, max - 3)}...`;
-}
-
-function buildDogfoodChecklist({ cases, outputText, turnCalls, youtubeCalls, logPath }) {
-  const turnCases = cases.filter(item => item.kind === 'turn');
-  const paired = turnCases.map((item, index) => ({ case: item, call: turnCalls[index] || null }));
-  const smallTalk = paired.filter(item => /small_talk|short_noise|greeting/.test(item.case.coverage));
-  const workspace = paired.filter(item => /workspace_|github_workspace_mutation|max_cloud/.test(item.case.coverage));
-  const cloud = paired.filter(item => item.case.expectRoute === 'cloud');
-  const bypassCall = paired.find(item => item.case.coverage === 'connector_write_bypass')?.call;
-  const safeCalls = paired.filter(item => /connector_write_(safe|resafe)/.test(item.case.coverage)).map(item => item.call);
-  const maxCall = paired.find(item => item.case.coverage === 'max_cloud')?.call;
-  const firstHeader = outputText.split(/\r?\n/).slice(0, 4).map(stripAnsi);
-  const longestHeader = firstHeader.reduce((max, line) => Math.max(max, line.length), 0);
-  const modelPattern = /atris:|composer-2-5|gpt-|kimi|fable|fireworks|openrouter/i;
-  const errorPattern = /Cannot access 'business'|Blocked: direct network access|ReferenceError|TypeError|UnhandledPromiseRejection|ECONNREFUSED|HTTP 5\d\d/i;
-
-  return [
-    makeChecklistItem('loops_25', 'Ran the requested loop count', cases.length === 25, `${cases.length}/25 loops`),
-    makeChecklistItem('header_compact', 'Chat header fits a small terminal', longestHeader <= 96 && /shift\+enter/.test(outputText), `longest header line ${longestHeader}`),
-    makeChecklistItem('menu_discoverable', 'Slash menu exposes key controls', /\/goal/.test(outputText) && /\/fast/.test(outputText) && /\/safe/.test(outputText), 'menu printed by /help and unknown slash'),
-    makeChecklistItem('small_talk_cloud', 'Greetings/noise avoid workspace listings', smallTalk.length >= 4 && smallTalk.every(item => item.call?.route === 'cloud' && !item.call?.workspace_path), smallTalk.map(item => `${item.case.input}:${item.call?.route}`).join(', ')),
-    makeChecklistItem('workspace_cloud_default', 'Workspace/code asks stay hosted by default', workspace.length >= 5 && workspace.every(item => item.call?.route === 'cloud' && !item.call?.workspace_path), workspace.map(item => `${item.case.coverage}:${item.call?.route}`).join(', ')),
-    makeChecklistItem('connectors_cloud', 'Connector reads/writes stay cloud by default', cloud.length >= 8 && cloud.every(item => item.call?.route === 'cloud'), cloud.map(item => `${item.case.coverage}:${item.call?.route}`).join(', ')),
-    makeChecklistItem('tier_switches', 'Tier commands affect following turns', maxCall?.mode === 'max', `max turn mode ${maxCall?.mode || 'missing'}`),
-    makeChecklistItem('permission_gates', 'Safe/bypass gates are visible in payloads', bypassCall?.allow_external_actions === true && safeCalls.every(call => call && call.allow_external_actions !== true), `bypass=${bypassCall?.allow_external_actions === true}; safe=${safeCalls.length}`),
-    makeChecklistItem('youtube_shortcut', 'YouTube URLs route to local processor path', youtubeCalls.length === 1 && !turnCalls.some(call => extractYoutubeUrl(call.message)), `${youtubeCalls.length} youtube call(s)`),
-    makeChecklistItem('no_model_ids', 'UI hides backend model ids', !modelPattern.test(outputText), 'no raw model ids in transcript'),
-    makeChecklistItem('no_error_patterns', 'Transcript has no known crash/block patterns', !errorPattern.test(outputText), 'business TDZ/network/crash patterns absent'),
-    makeChecklistItem('log_written', 'Dogfood leaves an inspectable ax run log', Boolean(logPath && fs.existsSync(logPath)), logPath || 'missing'),
-  ];
-}
-
-async function runChatDogfood(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const loops = Math.max(1, Number(options.loops) || 25);
-  const cases = buildChatDogfoodCases(loops);
-  const startedAt = Date.now();
-  const chunks = [];
-  const output = options.output || {
-    isTTY: true,
-    color: false,
-    write(chunk) {
-      chunks.push(String(chunk || ''));
-      return true;
-    },
-  };
-  const turnCalls = [];
-  const youtubeCalls = [];
-  const turnFunction = options.live === true ? undefined : async (message, turnOptions = {}) => {
-    const route = resolveRoute(message, turnOptions);
-    const payload = buildPayload(message, { ...turnOptions, route });
-    const record = {
-      message,
-      mode: normalizeMode(turnOptions.mode),
-      route,
-      workspace_path: payload.workspace_path || null,
-      max_turns: payload.max_turns,
-      bypass_permissions: payload.bypass_permissions === true,
-      allow_external_actions: payload.allow_external_actions === true,
-    };
-    turnCalls.push(record);
-    const text = `dogfood ok: ${record.mode}/${record.route}`;
-    if (turnOptions.output) turnOptions.output.write(text);
-    return {
-      output: text,
-      durationMs: 1,
-      events: [{ type: 'receipt', receipt: { billing: { billed: false }, dogfood: record } }],
-    };
-  };
-  const youtubeCommand = async (argv, deps = {}) => {
-    youtubeCalls.push(argv);
-    if (deps.output) deps.output(`dogfood youtube: ${argv[0] || 'missing-url'}`);
-    return 0;
-  };
-  const input = Readable.from(cases.map(item => `${item.input}\n`).concat('exit\n'));
-
-  await chat({
-    mode: 'fast',
-    cwd,
-    input,
-    output,
-    turnFunction,
-    youtubeCommand: options.youtubeCommand || youtubeCommand,
-    persistPrefs: false,
-    bypassPermissions: false,
-  });
-
-  const outputText = typeof output.text === 'function' ? output.text() : chunks.join('');
-  const logPath = newestAxLog(cwd, startedAt - 1000);
-  const checklist = buildDogfoodChecklist({ cases, outputText, turnCalls, youtubeCalls, logPath });
-  const failures = checklist.filter(item => !item.passed);
-  return {
-    schema: 'atris.ax_chat_dogfood.v1',
-    mode: 'fast',
-    loops_requested: loops,
-    loops_run: cases.length,
-    dry_run: options.live !== true,
-    cwd,
-    log_path: logPath,
-    turn_calls: turnCalls,
-    youtube_calls: youtubeCalls,
-    checklist,
-    failures,
-    output: outputText,
-  };
-}
-
-function formatChatDogfoodReport(report) {
-  const passed = report.checklist.filter(item => item.passed).length;
-  const lines = [
-    'Ax fast chat dogfood',
-    `loops: ${report.loops_run}/${report.loops_requested}`,
-    `checklist: ${passed}/${report.checklist.length} passed`,
-    `log: ${report.log_path || 'missing'}`,
-    '',
-  ];
-  for (const item of report.checklist) {
-    lines.push(`${item.passed ? 'ok' : 'fail'} ${item.id} — ${item.evidence || item.label}`);
-  }
-  if (report.failures.length) {
-    lines.push('');
-    lines.push(`failures: ${report.failures.map(item => item.id).join(', ')}`);
-  }
-  return lines.join('\n');
-}
-
-function safeJsonFile(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return null;
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function readJsonlRows(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return [];
-    return fs.readFileSync(filePath, 'utf8')
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map(line => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-function parseDogfoodVerifierOutput(stdout = '') {
-  const text = String(stdout || '');
-  const loops = text.match(/loops:\s*(\d+)\/(\d+)/i);
-  const checklist = text.match(/checklist:\s*(\d+)\/(\d+)\s+passed/i);
-  const log = text.match(/^log:\s*(.+)$/im);
-  return {
-    loops_passed: loops ? Number(loops[1]) : 0,
-    loops_total: loops ? Number(loops[2]) : 0,
-    checklist_passed: checklist ? Number(checklist[1]) : 0,
-    checklist_total: checklist ? Number(checklist[2]) : 0,
-    log_path: log ? log[1].trim() : null,
-  };
-}
-
-function latestDogfoodMission(cwd = process.cwd()) {
-  const rows = readJsonlRows(path.join(cwd, '.atris', 'state', 'missions.jsonl'));
-  const byId = new Map();
-  for (const row of rows) {
-    if (!row || row.schema !== 'atris.mission.v1') continue;
-    if (!/--dogfood-chat/.test(String(row.verifier || ''))) continue;
-    byId.set(row.id, row);
-  }
-  const missions = Array.from(byId.values());
-  missions.sort((a, b) => new Date(b.updated_at || b.created_at || 0) - new Date(a.updated_at || a.created_at || 0));
-  return missions[0] || null;
-}
-
-function collectDogfoodTicks(cwd, mission) {
-  const runsDir = path.join(cwd, 'atris', 'runs');
-  const out = new Map();
-  if (!mission || !mission.id || !fs.existsSync(runsDir)) return [];
-  const prefix = `mission-${mission.id}-`;
-  for (const name of fs.readdirSync(runsDir)) {
-    if (!name.startsWith(prefix) || !name.endsWith('.json')) continue;
-    const full = path.join(runsDir, name);
-    const payload = safeJsonFile(full);
-    if (!payload) continue;
-    let mtimeMs = 0;
-    try {
-      mtimeMs = fs.statSync(full).mtimeMs;
-    } catch {}
-    const body = payload.result || payload;
-    const stdout = body.verifier_result?.stdout || payload.verifier_result?.stdout || payload.mission?.verifier_result?.stdout || '';
-    const ticks = [];
-    if (payload.tick) ticks.push(payload.tick);
-    if (body.tick) ticks.push(body.tick);
-    if (Array.isArray(payload.ticks)) ticks.push(...payload.ticks);
-    if (Array.isArray(body.ticks)) ticks.push(...body.ticks);
-    for (const tick of ticks) {
-      const index = Number(tick && tick.tick_index);
-      if (!Number.isFinite(index) || index < 1) continue;
-      const previous = out.get(index);
-      if (previous && previous.mtimeMs > mtimeMs) continue;
-      const summary = parseDogfoodVerifierOutput(stdout);
-      out.set(index, {
-        index,
-        verifier_passed: tick.verifier_passed === true || body.verifier_result?.passed === true || payload.verifier_result?.passed === true,
-        receipt_path: path.relative(cwd, full),
-        mtimeMs,
-        ...summary,
-      });
-    }
-  }
-  return Array.from(out.values()).sort((a, b) => a.index - b.index);
-}
-
-function dogfoodCrontabInstalled(crontabText = null) {
-  const text = crontabText !== null ? String(crontabText || '') : (() => {
-    try {
-      const res = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 8000 });
-      return res.status === 0 ? String(res.stdout || '') : '';
-    } catch {
-      return '';
-    }
-  })();
-  return /ATRIS_AX_FAST_CHAT_DOGFOOD/.test(text);
-}
-
-function countDogfoodCronRuns(cwd = process.cwd(), cronLogText = null) {
-  const text = cronLogText !== null
-    ? String(cronLogText || '')
-    : String(safeReadText(path.join(cwd, 'atris', 'runs', 'ax-fast-chat-overnight-cron.log')) || '');
-  return (text.match(/^=== ax fast chat dogfood tick /gm) || []).length;
-}
-
-function safeReadText(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) return '';
-    return fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return '';
-  }
+function printBackendHint() {
+  console.log('');
+  console.log(formatBackendHint());
 }
 
-function buildChatDogfoodStatus(options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const targetLoops = Math.max(1, Number(options.targetLoops) || 25);
-  const mission = options.mission || latestDogfoodMission(cwd);
-  const ticks = collectDogfoodTicks(cwd, mission);
-  const cleanTicks = ticks.filter(tick => tick.verifier_passed && tick.loops_passed > 0);
-  const cleanLoops = cleanTicks.reduce((sum, tick) => sum + tick.loops_passed, 0);
-  const latestClean = cleanTicks[cleanTicks.length - 1] || null;
-  const latestTick = ticks[ticks.length - 1] || null;
-  const checklistPassed = latestClean && latestClean.checklist_total > 0 && latestClean.checklist_passed === latestClean.checklist_total;
-  const cronInstalled = dogfoodCrontabInstalled(options.crontabText ?? null);
-  const cronRuns = countDogfoodCronRuns(cwd, options.cronLogText ?? null);
-  return {
-    schema: 'atris.ax_chat_dogfood_status.v1',
-    cwd,
-    mission_id: mission ? mission.id : null,
-    mission_status: mission ? mission.status : null,
-    mission_cadence: mission ? mission.cadence : null,
-    last_tick_index: mission ? Number(mission.last_tick_index || 0) : 0,
-    last_tick_at: mission ? mission.last_tick_at || null : null,
-    target_loops: targetLoops,
-    clean_chat_loops: cleanLoops,
-    remaining_loops: Math.max(0, targetLoops - cleanLoops),
-    target_met: cleanLoops >= targetLoops,
-    clean_tick_count: cleanTicks.length,
-    latest_receipt_path: latestClean ? latestClean.receipt_path : latestTick ? latestTick.receipt_path : null,
-    latest_log_path: latestClean ? latestClean.log_path : null,
-    latest_checklist_passed: checklistPassed === true,
-    cron_installed: cronInstalled,
-    cron_runs: cronRuns,
-    overnight_proven: cronRuns > 0 && cleanLoops >= targetLoops,
-  };
+function backendStartCommand() {
+  return `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 formatChatDogfoodStatusReport(status) {
-  const lines = [
-    'Ax fast chat overnight',
-    `mission: ${status.mission_id || 'missing'}`,
-    `status: ${status.mission_status || 'missing'} · cadence ${status.mission_cadence || 'n/a'}`,
-    `loops: ${status.clean_chat_loops}/${status.target_loops} clean (${status.remaining_loops} remaining)`,
-    `ticks: ${status.clean_tick_count} clean · last ${status.last_tick_index || 0} at ${status.last_tick_at || 'never'}`,
-    `checklist: ${status.latest_checklist_passed ? 'passed' : 'missing/failing'}`,
-    `cron: ${status.cron_installed ? 'installed' : 'missing'} · runs ${status.cron_runs}`,
-    `receipt: ${status.latest_receipt_path || 'missing'}`,
-    `log: ${status.latest_log_path || 'missing'}`,
-  ];
-  lines.push(status.overnight_proven ? 'result: overnight 25-loop proof is complete' : 'result: still collecting overnight proof');
-  return lines.join('\n');
-}
-
-function printBackendHint(options = {}) {
-  console.log('');
-  console.log('Hosted lane:');
-  console.log('ax --cloud "hello"');
-  console.log('');
-  console.log('Cloud API:');
-  console.log(`ATRIS_API_BASE=${BACKEND.publicBase}`);
-  if (options.route === 'local' || options.forceLocal) {
-    console.log('');
-    console.log('Local developer lane:');
-    console.log(`Set AX_BACKEND_URL=http://${BACKEND.host}:${BACKEND.port} after starting your local Atris2 service.`);
-  }
+function formatBackendHint() {
+  return `Start backend:\n${backendStartCommand()}`;
 }
 
 function bufferedOutput() {
@@ -2942,6 +2198,535 @@ async function runBenchmarkCase(label, fn, results, output) {
   }
 }
 
+async function runSelfTestCase(label, fn, results, output) {
+  output.write(`- ${label} ... `);
+  try {
+    await fn();
+    output.write('ok\n');
+    results.push({ label, ok: true });
+  } catch (error) {
+    output.write(`fail - ${error.message}\n`);
+    results.push({ label, ok: false, error: error.message });
+  }
+}
+
+function assertSelfTest(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+async function runSelfTest(options = {}) {
+  const output = options.output || process.stdout;
+  const results = [];
+  output.write('AX self-test\n\n');
+
+  await runSelfTestCase('doctor redaction', async () => {
+    const health = await buildRuntimeHealth({
+      healthRes: {
+        ok: true,
+        status: 200,
+        data: {
+          ready: true,
+          models: [{
+            id: 'atris:fast',
+            route: 'fireworks',
+            chat_model: 'fireworks:glm-5.2',
+            tool_model: 'fireworks:glm-5.2',
+            ready: true,
+          }],
+        },
+      },
+    });
+    const text = formatRuntimeHealth(health, { color: false });
+    assertSelfTest(/backend\s+ready/.test(text), 'backend readiness missing');
+    assertSelfTest(/fast\s+ready/.test(text), 'fast readiness missing');
+    assertSelfTest(!/atris:|fireworks|glm|secret|token/i.test(text), 'doctor output leaked provider/debug text');
+  }, results, output);
+
+  await runSelfTestCase('chat backend offline preflight', async () => {
+    const previousAuto = process.env.AX_AUTO_LOG;
+    process.env.AX_AUTO_LOG = '0';
+    const chunks = [];
+    const chatOutput = {
+      isTTY: false,
+      write(chunk) {
+        chunks.push(String(chunk || ''));
+        return true;
+      },
+    };
+    let healthCalls = 0;
+    try {
+      await chat({
+        mode: 'fast',
+        cwd: os.tmpdir(),
+        input: Readable.from(['hi\n', 'exit\n']),
+        output: chatOutput,
+        runtimeHealth: async () => {
+          healthCalls += 1;
+          return {
+            schema: 'ax.runtime_health.v1',
+            backend: { ready: false, reachable: false, status: 0, error: 'ECONNREFUSED secret-token' },
+            fast: { ready: false, route_ready: false },
+            permissions: { ready: false },
+          };
+        },
+      });
+    } finally {
+      if (previousAuto === undefined) delete process.env.AX_AUTO_LOG;
+      else process.env.AX_AUTO_LOG = previousAuto;
+    }
+    const text = chunks.join('');
+    assertSelfTest(healthCalls === 1, 'offline preflight repeated unexpectedly');
+    assertSelfTest(/backend\s+offline/.test(text), 'offline backend status missing');
+    assertSelfTest(/Start backend:/.test(text) && /uvicorn main:app/.test(text), 'start-backend command missing');
+    assertSelfTest(!/secret-token/.test(text), 'offline preflight leaked error detail');
+  }, results, output);
+
+  await runSelfTestCase('approval id', async () => {
+    const receipt = {
+      tool_events: [{
+        approval_request: {
+          connector: 'slack',
+          executor_action_type: 'slack_post_message',
+          status: 'approval_required',
+          payload: { channel: '#general', text: 'ship note' },
+        },
+      }],
+    };
+    const first = approvalRequestFromReceipt(receipt);
+    const second = approvalRequestFromReceipt(receipt);
+    assertSelfTest(first && /^apreq_ax_[a-f0-9]{20}$/.test(first.approval_request_id), 'stable approval id missing');
+    assertSelfTest(first.approval_request_id === second.approval_request_id, 'approval id was not stable');
+  }, results, output);
+
+  await runSelfTestCase('calendar approval rail', async () => {
+    const payload = buildPayload('add calendar event today at 2pm', {
+      mode: 'fast',
+      route: 'cloud',
+      connectionContext: {
+        schema: 'atris.connection_capabilities.v1',
+        source: 'ax',
+        connections: [{
+          id: 'google-calendar',
+          connected: true,
+          actions: ['list_events', 'create_event'],
+          authority: { list_events: 'read_only', create_event: 'approval_required' },
+        }],
+      },
+    });
+    assertSelfTest(payload.workspace_path === undefined, 'calendar write should stay on cloud approval route');
+    assertSelfTest(payload.allow_external_actions === undefined, 'calendar write bypassed approval rail');
+    assertSelfTest(payload.cleanup_external_actions === undefined, 'calendar write requested cleanup bypass');
+  }, results, output);
+
+  await runSelfTestCase('calendar approval execution', async () => {
+    const approvalRequest = {
+      connector: 'google_calendar',
+      action: 'create_event',
+      executor_action_type: 'google_calendar_create_event',
+      status: 'approval_required',
+      payload: {
+        summary: 'markoo',
+        start: { dateTime: '2026-06-28T14:00:00-07:00' },
+        end: { dateTime: '2026-06-28T15:00:00-07:00' },
+      },
+    };
+    const previewOnly = {
+      tool_events: [{ approval_request: approvalRequest }],
+    };
+    assertSelfTest(approvalExecutionRequestFromReceipt(previewOnly) === null, 'preview-only calendar receipt would execute');
+
+    const accepted = {
+      task_accept_receipt: {
+        accepted: true,
+        task: 'calendar.create_event',
+        execution_status: 'pending_approval_execution',
+        execution_endpoint: APPROVAL_EXECUTE_PATH,
+      },
+      tool_events: [{ approval_request: approvalRequest }],
+    };
+    const executable = approvalExecutionRequestFromReceipt(accepted);
+    assertSelfTest(executable && /^apreq_ax_[a-f0-9]{20}$/.test(executable.approval_request_id), 'accepted calendar approval lacks stable id');
+    assertSelfTest(executable.executor_action_type === 'google_calendar_create_event', 'wrong calendar executor action');
+    assertSelfTest(executable.payload && executable.payload.summary === 'markoo', 'calendar approval payload changed');
+  }, results, output);
+
+  await runSelfTestCase('calendar chat approval loop', async () => {
+    const chunks = [];
+    const chatOutput = {
+      isTTY: false,
+      write(chunk) {
+        chunks.push(String(chunk || ''));
+        return true;
+      },
+    };
+    const approvalRequest = {
+      connector: 'google_calendar',
+      action: 'create_event',
+      executor_action_type: 'google_calendar_create_event',
+      status: 'approval_required',
+      payload: {
+        summary: 'markoo',
+        start: { dateTime: '2026-06-28T14:00:00-07:00' },
+        end: { dateTime: '2026-06-28T15:00:00-07:00' },
+      },
+    };
+    const firstFinal = "I'll add it today at 2:00 PM.\nWhat should I call it?";
+    const firstTaskPreview = {
+      task: 'calendar.create_event',
+      owner_member: 'harness-engineer',
+      status: 'needs_input',
+      missing: ['title'],
+      slots: {
+        date: '2026-06-28',
+        start: '2026-06-28T14:00:00-07:00',
+        end: '2026-06-28T15:00:00-07:00',
+      },
+    };
+    const secondFinal = 'Ready to create: markoo today at 2:00 PM.\nCreate it?';
+    const secondTaskPreview = {
+      task: 'calendar.create_event',
+      owner_member: 'harness-engineer',
+      status: 'approval_required',
+      missing: [],
+      slots: {
+        title: 'markoo',
+        date: '2026-06-28',
+        start: '2026-06-28T14:00:00-07:00',
+        end: '2026-06-28T15:00:00-07:00',
+      },
+    };
+    const turns = [];
+    const approvals = [];
+    await chat({
+      mode: 'fast',
+      route: 'cloud',
+      cwd: os.tmpdir(),
+      conversationId: 'ax-self-test-calendar-chat',
+      input: Readable.from(['add calendar event today at 2pm\n', 'markoo\n', 'yes\n', 'exit\n']),
+      output: chatOutput,
+      turnFunction: async (message, turnOptions) => {
+        turns.push({ message, route: turnOptions.route, historyLength: turnOptions.history.length });
+        const receipt = turns.length === 1
+          ? {
+              final: firstFinal,
+              task_preview: firstTaskPreview,
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'blocked_missing_details' }],
+            }
+          : {
+              final: secondFinal,
+              task_preview: secondTaskPreview,
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'approval_required', approval_request: approvalRequest }],
+            };
+        turnOptions.output.write(receipt.final);
+        return { output: receipt.final, durationMs: 1, events: [{ type: 'receipt', receipt }] };
+      },
+      postApproval: async (request) => {
+        approvals.push(request);
+        return {
+          ok: true,
+          status: 200,
+          data: {
+            status: 'executed',
+            action_type: 'google_calendar_create_event',
+            execution: { status: 'executed', action_type: 'google_calendar_create_event', executed: true },
+          },
+        };
+      },
+    });
+    const text = chunks.join('');
+    assertSelfTest(turns.length === 2, 'approval yes triggered another model/backend turn');
+    assertSelfTest(turns[1].route === 'cloud', 'slot-fill follow-up did not stay on cloud approval route');
+    assertSelfTest(approvals.length === 1, 'approval execution was not called exactly once');
+    assertSelfTest(approvals[0].executor_action_type === 'google_calendar_create_event', 'chat loop executed wrong approval action');
+    const previewRows = formatTaskPreviewRows({
+      task_preview: secondTaskPreview,
+      tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'approval_required', approval_request: approvalRequest }],
+    }, { color: false }).join('\n');
+    assertSelfTest(/owner\s+harness-engineer/.test(previewRows), 'task preview owner row missing');
+    assertSelfTest(/plan\s+create calendar event "markoo" Jun 28, 2026 at 2:00 PM/.test(previewRows), 'task preview plan row missing');
+    assertSelfTest(/check\s+approval required/.test(previewRows), 'task preview check row missing');
+    assertSelfTest(/Accepted\./.test(text) && /Created calendar event\./.test(text), 'chat loop did not render accepted execution result');
+  }, results, output);
+
+  await runSelfTestCase('calendar blocked approval retry', async () => {
+    const chunks = [];
+    const chatOutput = {
+      isTTY: false,
+      write(chunk) {
+        chunks.push(String(chunk || ''));
+        return true;
+      },
+    };
+    const approvalRequest = {
+      connector: 'google_calendar',
+      action: 'create_event',
+      executor_action_type: 'google_calendar_create_event',
+      status: 'approval_required',
+      payload: {
+        summary: 'markoo',
+        start: { dateTime: '2026-06-28T14:00:00-07:00' },
+        end: { dateTime: '2026-06-28T15:00:00-07:00' },
+      },
+    };
+    const turns = [];
+    const approvals = [];
+    await chat({
+      mode: 'fast',
+      route: 'cloud',
+      cwd: os.tmpdir(),
+      conversationId: 'ax-self-test-calendar-blocked-retry',
+      input: Readable.from(['add calendar event today at 2pm\n', 'markoo\n', 'yes\n', 'yes\n', 'exit\n']),
+      output: chatOutput,
+      turnFunction: async (message, turnOptions) => {
+        turns.push({ message, route: turnOptions.route, historyLength: turnOptions.history.length });
+        const receipt = turns.length === 1
+          ? {
+              final: "I'll add it today at 2:00 PM.\nWhat should I call it?",
+              task_preview: {
+                task: 'calendar.create_event',
+                status: 'needs_input',
+                missing: ['title'],
+                slots: {
+                  date: '2026-06-28',
+                  start: '2026-06-28T14:00:00-07:00',
+                  end: '2026-06-28T15:00:00-07:00',
+                },
+              },
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'blocked_missing_details' }],
+            }
+          : {
+              final: 'Ready to create: markoo today at 2:00 PM.\nCreate it?',
+              task_preview: {
+                task: 'calendar.create_event',
+                status: 'approval_required',
+                missing: [],
+                slots: {
+                  title: 'markoo',
+                  date: '2026-06-28',
+                  start: '2026-06-28T14:00:00-07:00',
+                  end: '2026-06-28T15:00:00-07:00',
+                },
+              },
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'approval_required', approval_request: approvalRequest }],
+            };
+        turnOptions.output.write(receipt.final);
+        return { output: receipt.final, durationMs: 1, events: [{ type: 'receipt', receipt }] };
+      },
+      postApproval: async (request) => {
+        approvals.push(request);
+        if (approvals.length === 1) {
+          return {
+            ok: false,
+            status: 402,
+            data: { detail: { error: 'paid_cloud_computer_required', action_type: 'google_calendar_create_event' } },
+          };
+        }
+        return {
+          ok: true,
+          status: 200,
+          data: {
+            status: 'executed',
+            action_type: 'google_calendar_create_event',
+            execution: { status: 'executed', action_type: 'google_calendar_create_event', executed: true },
+          },
+        };
+      },
+    });
+    const text = chunks.join('');
+    assertSelfTest(turns.length === 2, 'blocked approval retry triggered another model/backend turn');
+    assertSelfTest(approvals.length === 2, 'blocked approval was not retryable');
+    assertSelfTest(approvals[0].approval_request_id === approvals[1].approval_request_id, 'retry changed approval id');
+    assertSelfTest(/Approval execution needs a paid cloud computer\./.test(text), 'blocked approval message missing');
+    assertSelfTest(/Created calendar event\./.test(text), 'retry success message missing');
+  }, results, output);
+
+  await runSelfTestCase('calendar chat denial loop', async () => {
+    const chunks = [];
+    const chatOutput = {
+      isTTY: false,
+      write(chunk) {
+        chunks.push(String(chunk || ''));
+        return true;
+      },
+    };
+    const approvalRequest = {
+      connector: 'google_calendar',
+      action: 'create_event',
+      executor_action_type: 'google_calendar_create_event',
+      status: 'approval_required',
+      payload: {
+        summary: 'markoo',
+        start: { dateTime: '2026-06-28T14:00:00-07:00' },
+        end: { dateTime: '2026-06-28T15:00:00-07:00' },
+      },
+    };
+    const turns = [];
+    const approvals = [];
+    await chat({
+      mode: 'fast',
+      route: 'cloud',
+      cwd: os.tmpdir(),
+      conversationId: 'ax-self-test-calendar-denial',
+      input: Readable.from(['add calendar event today at 2pm\n', 'markoo\n', 'no\n', 'exit\n']),
+      output: chatOutput,
+      turnFunction: async (message, turnOptions) => {
+        turns.push({ message, route: turnOptions.route, historyLength: turnOptions.history.length });
+        const receipt = turns.length === 1
+          ? {
+              final: "I'll add it today at 2:00 PM.\nWhat should I call it?",
+              task_preview: {
+                task: 'calendar.create_event',
+                status: 'needs_input',
+                missing: ['title'],
+                slots: {
+                  date: '2026-06-28',
+                  start: '2026-06-28T14:00:00-07:00',
+                  end: '2026-06-28T15:00:00-07:00',
+                },
+              },
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'blocked_missing_details' }],
+            }
+          : {
+              final: 'Ready to create: markoo today at 2:00 PM.\nCreate it?',
+              task_preview: {
+                task: 'calendar.create_event',
+                status: 'approval_required',
+                missing: [],
+                slots: {
+                  title: 'markoo',
+                  date: '2026-06-28',
+                  start: '2026-06-28T14:00:00-07:00',
+                  end: '2026-06-28T15:00:00-07:00',
+                },
+              },
+              tool_events: [{ tool: 'google_calendar', action: 'create_event', status: 'approval_required', approval_request: approvalRequest }],
+            };
+        turnOptions.output.write(receipt.final);
+        return { output: receipt.final, durationMs: 1, events: [{ type: 'receipt', receipt }] };
+      },
+      postApproval: async (request) => {
+        approvals.push(request);
+        return { ok: true, status: 200, data: { status: 'executed' } };
+      },
+    });
+    const text = chunks.join('');
+    assertSelfTest(turns.length === 2, 'denial triggered another model/backend turn');
+    assertSelfTest(approvals.length === 0, 'denial executed an approval action');
+    assertSelfTest(/Cancelled\./.test(text), 'denial did not render cancellation');
+  }, results, output);
+
+  await runSelfTestCase('approval queue privacy', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ax-self-test-approvals-'));
+    const storePath = path.join(dir, 'approvals.json');
+    try {
+      const receipt = {
+        task_preview: {
+          task: 'slack.post_message',
+          owner_member: 'comms',
+          status: 'approval_required',
+          missing: [],
+        },
+        tool_events: [{
+          tool: 'slack',
+          approval_request: {
+            connector: 'slack',
+            action: 'post_message',
+            executor_action_type: 'slack_post_message',
+            status: 'approval_required',
+            payload: { channel: '#general', text: 'secret payload text' },
+          },
+        }],
+      };
+      const request = approvalRequestFromReceipt(receipt);
+      const record = persistPendingApproval(receipt, request, { storePath, cwd: dir, mode: 'fast' });
+      const mode = fs.statSync(storePath).mode & 0o777;
+      const listed = formatStoredApprovals(readApprovalStore({ storePath }), { color: false });
+      assertSelfTest(record && record.id, 'approval queue record missing');
+      assertSelfTest(mode === 0o600, `approval queue mode was ${mode.toString(8)}`);
+      assertSelfTest(/owner\s+comms/.test(listed), 'approval queue owner missing');
+      assertSelfTest(!/secret payload text/.test(listed), 'approval queue list leaked payload');
+      denyStoredApproval(record.id, { storePath });
+      assertSelfTest(readApprovalStore({ storePath }).approvals.length === 0, 'approval denial did not remove queue record');
+
+      const oldCreatedAt = new Date(Date.now() - (25 * 60 * 60 * 1000)).toISOString();
+      const stale = persistPendingApproval(receipt, request, { storePath, cwd: dir, mode: 'fast', createdAt: oldCreatedAt });
+      let executed = false;
+      const staleOutput = {
+        isTTY: false,
+        chunks: [],
+        write(chunk) {
+          this.chunks.push(String(chunk || ''));
+          return true;
+        },
+      };
+      const result = await approveStoredApproval(stale.id, {
+        storePath,
+        output: staleOutput,
+        postApproval: async () => {
+          executed = true;
+          return { ok: true, status: 200, data: {} };
+        },
+      });
+      assertSelfTest(result && result.stale === true, 'stale approval was not marked stale');
+      assertSelfTest(executed === false, 'stale approval executed');
+      assertSelfTest(readApprovalStore({ storePath }).approvals.length === 0, 'stale approval was not removed');
+      assertSelfTest(/Approval expired/.test(staleOutput.chunks.join('')), 'stale approval message missing');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  }, results, output);
+
+  await runSelfTestCase('approval output privacy', async () => {
+    const text = formatApprovalExecutionResult({
+      ok: false,
+      status: 402,
+      data: { detail: { error: 'paid_cloud_computer_required', message: 'secret payload text' } },
+    });
+    assertSelfTest(text === 'Approval execution needs a paid cloud computer.', 'unexpected approval failure text');
+    assertSelfTest(!/secret payload/i.test(text), 'approval failure leaked private detail');
+  }, results, output);
+
+  await runSelfTestCase('run log privacy', async () => {
+    const previousFull = process.env.AX_LOG_FULL;
+    const previousAuto = process.env.AX_AUTO_LOG;
+    delete process.env.AX_LOG_FULL;
+    delete process.env.AX_AUTO_LOG;
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'ax-self-test-log-'));
+    fs.mkdirSync(path.join(cwd, 'atris'), { recursive: true });
+    try {
+      const logger = createRunLogger({
+        cwd,
+        mode: 'fast',
+        kind: 'self-test',
+        output: { isTTY: true, write() { return true; } },
+      });
+      assertSelfTest(logger, 'logger was not created');
+      logger.output.write('private input secret\n');
+      logger.write('private output secret\n');
+      logger.close(0);
+      const logText = fs.readFileSync(logger.path, 'utf8');
+      assertSelfTest(/transcript: redacted/.test(logText), 'redacted transcript marker missing');
+      assertSelfTest(!/private input secret|private output secret/.test(logText), 'run log leaked private text');
+    } finally {
+      if (previousFull === undefined) delete process.env.AX_LOG_FULL;
+      else process.env.AX_LOG_FULL = previousFull;
+      if (previousAuto === undefined) delete process.env.AX_AUTO_LOG;
+      else process.env.AX_AUTO_LOG = previousAuto;
+      fs.rmSync(cwd, { recursive: true, force: true });
+    }
+  }, results, output);
+
+  const failed = results.filter(result => !result.ok);
+  output.write('\n');
+  output.write(failed.length ? `Self-test failed: ${failed.length}/${results.length} failed\n` : `Self-test 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 runBenchmark(options = {}) {
   const normalized = normalizeMode(options.mode);
   const mode = normalized === 'code-fast' ? 'fast' : normalized;
@@ -3063,35 +2848,12 @@ async function runBenchmark(options = {}) {
 }
 
 async function main() {
-  let args = process.argv.slice(2);
-  if (isAxSpawnCommand(args[0])) {
-    try {
-      runAxSpawnCommand(args, { root: process.cwd() });
-    } catch (error) {
-      console.error(`x ${error.message}`);
-      process.exit(1);
-    }
-    return;
-  }
-  if (args[0] === 'youtube') {
-    try {
-      await runAxYoutubeCommand(args, { output: (line = '') => console.log(line) });
-    } catch (error) {
-      console.error(`x ${error.message}`);
-      process.exit(1);
-    }
-    return;
-  }
+  const args = process.argv.slice(2);
   if (args.includes('--help') || args.includes('-h')) {
     console.log(formatUsage());
     return;
   }
 
-  const bypassPermissions = parsePermissionFlags(args);
-  args = stripPermissionFlags(args);
-  const chatArgs = normalizeChatCommandArgs(args);
-  args = chatArgs.args;
-
   // --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;
@@ -3118,63 +2880,42 @@ async function main() {
     args.splice(verifyIdx, 2);
   }
 
-  let dogfoodLoops = 25;
-  const loopsIdx = args.indexOf('--loops');
-  if (loopsIdx !== -1) {
-    dogfoodLoops = Number(args[loopsIdx + 1]);
-    if (!Number.isInteger(dogfoodLoops) || dogfoodLoops < 1 || dogfoodLoops > 100) {
-      console.error('Usage: ax --dogfood-chat --loops <1-100>');
-      process.exit(1);
-    }
-    args.splice(loopsIdx, 2);
-  }
-
-  const mode = args.includes('--code-fast') || args.includes('--code') ? 'code-fast'
-    : args.includes('--max') ? 'max'
-      : args.includes('--pro') ? 'pro'
-        : 'fast';
+  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 selfTest = args.includes('--self-test');
   const benchmark = args.includes('--benchmark');
-  const dogfoodChat = args.includes('--dogfood-chat');
-  const dogfoodStatus = args.includes('--dogfood-status');
-  const dogfoodJson = dogfoodChat && args.includes('--json');
-  const dogfoodLive = dogfoodChat && args.includes('--live');
+  const approvals = args.includes('--approvals');
   const forceCloud = args.includes('--cloud');
   const forceLocal = args.includes('--local');
-  const route = forceCloud ? 'cloud' : forceLocal ? 'local' : 'auto';
-  const prompt = args
-    .filter(arg => !['--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--benchmark', '--dogfood-chat', '--dogfood-status', '--json', '--live', '--local', '--cloud', '--help', '-h'].includes(arg))
-    .join(' ')
-    .trim();
-
-  if (dogfoodStatus) {
-    const status = buildChatDogfoodStatus({ cwd: process.cwd(), targetLoops: dogfoodLoops });
-    console.log(args.includes('--json') ? JSON.stringify(status, null, 2) : formatChatDogfoodStatusReport(status));
-    return;
-  }
 
-  if (dogfoodChat) {
-    try {
-      const report = await runChatDogfood({ mode, cwd: process.cwd(), loops: dogfoodLoops, live: dogfoodLive });
-      console.log(dogfoodJson ? JSON.stringify(report, null, 2) : formatChatDogfoodReport(report));
-      if (report.failures.length) process.exit(1);
-    } catch (error) {
-      console.error(`x ${error.message}`);
+  let approveId = '';
+  const approveIdx = args.indexOf('--approve');
+  if (approveIdx !== -1) {
+    approveId = String(args[approveIdx + 1] || '').trim();
+    if (!approveId) {
+      console.error('Usage: ax --approve <approval-id>');
       process.exit(1);
     }
-    return;
+    args.splice(approveIdx, 2);
   }
 
-  if (prompt && extractYoutubeUrl(prompt)) {
-    try {
-      await runAxYoutubeCommand([prompt], { output: (line = '') => console.log(line) });
-    } catch (error) {
-      console.error(`x ${error.message}`);
+  let denyId = '';
+  const denyIdx = args.indexOf('--deny');
+  if (denyIdx !== -1) {
+    denyId = String(args[denyIdx + 1] || '').trim();
+    if (!denyId) {
+      console.error('Usage: ax --deny <approval-id>');
       process.exit(1);
     }
-    return;
+    args.splice(denyIdx, 2);
   }
 
+  const route = forceCloud ? 'cloud' : forceLocal ? 'local' : 'auto';
+  const prompt = args
+    .filter(arg => !['--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--approvals', '--self-test', '--benchmark', '--local', '--cloud', '--help', '-h'].includes(arg))
+    .join(' ')
+    .trim();
+
   let business = null;
   if (businessSlug) {
     if (normalizeMode(mode) === 'code-fast') {
@@ -3206,46 +2947,61 @@ async function main() {
     console.log(`cloud workspace: ${biz.businessName || businessSlug}`);
   }
 
-  const runOptions = {
-    mode,
-    cwd: process.cwd(),
-    route: route === 'auto' ? undefined : route,
-    business,
-    verify,
-    bypassPermissions,
-  };
-
   try {
+    if (selfTest) {
+      await runSelfTest({ output: process.stdout });
+      return;
+    }
+
     if (benchmark) {
       await runBenchmark({ mode, cwd: process.cwd(), output: process.stdout });
       return;
     }
 
     if (doctor) {
-      console.log(formatHeader({ mode, cwd: process.cwd(), chat: false, bypassPermissions: resolveBypassPermissions(runOptions) }, process.stdout));
+      console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
       console.log('');
-      console.log(formatRunProfile(buildRunProfile(runOptions), process.stdout));
+      console.log(formatRunProfile(buildRunProfile({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route }), process.stdout));
+      console.log('');
+      console.log(formatRuntimeHealth(await buildRuntimeHealth(), process.stdout));
       return;
     }
 
-    if (!prompt || chatArgs.chatRequested) {
-      await chat(runOptions);
+    if (approvals) {
+      console.log(formatStoredApprovals(readApprovalStore(), process.stdout));
       return;
     }
 
-    console.log(formatHeader({ mode, cwd: process.cwd(), chat: false, bypassPermissions: resolveBypassPermissions(runOptions) }, process.stdout));
-    console.log('');
-    const result = await turnFunctionForMode(mode)(prompt, runOptions);
-    if (result.interrupted) {
-      console.log('');
-      console.log('· Interrupted');
-      process.exit(130);
+    if (approveId) {
+      await approveStoredApproval(approveId, { mode, output: process.stdout });
+      return;
+    }
+
+    if (denyId) {
+      const record = denyStoredApproval(denyId);
+      console.log(`Cancelled pending approval ${record.id}.`);
+      return;
     }
+
+    if (!prompt || args.includes('--chat')) {
+      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
+      return;
+    }
+
+    console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
+    console.log('');
+    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);
+    const approvalRecord = approvalRequest
+      ? persistPendingApproval(receipt, approvalRequest, { cwd: process.cwd(), mode })
+      : null;
+    if (approvalRecord) console.log(formatAuxRow('approve', formatApprovalCommand(approvalRecord.id), process.stdout));
     console.log('');
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    printBackendHint(runOptions);
+    printBackendHint();
     process.exit(1);
   }
 }
@@ -3257,87 +3013,67 @@ if (require.main === module) {
 module.exports = {
   authToken,
   authUserId,
+  approvalExecutionRequestFromReceipt,
+  approvalRequestFromReceipt,
+  approvalStorePath,
+  approveStoredApproval,
   backendBaseUrl,
+  backendStartCommand,
   backendUrl,
-  buildAxYoutubeArgs,
   buildCodeFastPayload,
-  buildChatDogfoodCases,
-  buildChatDogfoodStatus,
-  buildMessage,
   buildPayload,
+  buildRuntimeHealth,
   cachedIntegrationStatus,
   buildConnectionContext,
   buildRunProfile,
   chat,
   chatCompleter,
-  chatGoalCommand: parseGoalCommand,
   chatMenu,
-  chatPermissionCommand,
   chatTierCommand,
-  loadAxPrefs,
-  MEMBER_SLUG,
-  parsePermissionFlags,
-  permissionsLabel,
-  printBackendHint,
-  resolveBypassPermissions,
-  runAxSpawnCommand,
-  setBypassPermissions,
   codeFastWorkspaceNotice,
   creditsFromState,
   codeFastBaseUrl,
   codeFastUrl,
   createRunLogger,
   createProgressReporter,
+  creditsFromApprovalExecution,
+  denyStoredApproval,
+  executeApprovalRequest,
+  executeApprovalFromState,
   formatDoneLine,
-  formatChatDogfoodReport,
-  formatChatDogfoodStatusReport,
   formatDuration,
+  formatApprovalExecutionResult,
+  formatApprovalReceipt,
+  formatBackendHint,
   formatHeader,
   formatPathSubject,
-  buildInputBoxBottomPlain,
-  buildInputBoxStatusPlain,
-  buildInputBoxTopPlain,
-  closeInputBox,
-  repaintInputBoxBottom,
-  formatChatInputInnerPrefix,
-  formatChatInputPrompt,
-  formatInputBoxBottom,
-  formatInputBoxInputRow,
-  formatInputBoxStatus,
-  formatInputBoxTop,
-  formatPermissionModeBrief,
-  formatPermissionToggleMessage,
   formatPrompt,
-  insertMultilineBreak,
-  inputBoxLayoutOptions,
-  inputBoxPlainWidth,
-  isMultilineInsertKey,
-  isPermissionToggleKey,
-  permissionAccentCodes,
   formatRunProfile,
+  formatRuntimeHealth,
   formatStatusMessage,
+  formatStoredApprovals,
   formatSystemInit,
+  formatTaskPreviewRows,
   formatUsage,
   formatWorkingLine,
   handleEvent,
-  extractYoutubeUrl,
-  isAxSpawnCommand,
-  manageTurnInterrupt,
+  latestPendingApprovalRequest,
+  messageApprovesPendingApproval,
+  messageCancelsPendingApproval,
   modelForMode,
-  normalizeChatCommandArgs,
   parseSseBlock,
+  persistPendingApproval,
+  postApprovalExecution,
   postCodeFastTurn,
   postTurn,
-  renderTerminalInline,
-  renderTerminalBlockLine,
-  formatMarkdownLink,
+  readApprovalStore,
+  removeStoredApproval,
   renderStreamingMarkdown,
-  renderShimmerText,
   renderTerminalMarkdown,
   resolveRoute,
   runBenchmark,
-  runChatDogfood,
-  runAxYoutubeCommand,
+  runSelfTest,
+  runtimeReadyForChat,
   summarizeToolInput,
   summarizeToolResult,
   tierLabel