atris 3.51.0 → 3.53.0

package/ax

@@ -78,7 +78,7 @@ const ANSI = {
   magenta: '\x1b[35m'
 };
 
-const TIER_COLORS = { fast: '\x1b[32m', pro: '\x1b[36m', max: '\x1b[35m' };
+const TIER_COLORS = { rapid: '\x1b[33m', fast: '\x1b[32m', pro: '\x1b[36m', max: '\x1b[35m' };
 
 // Extend backend_api by adding one row here. Keep mutating endpoints narrow;
 // any non-get method is approval-gated before the HTTP request is made.
@@ -99,6 +99,7 @@ function tierColor(mode) {
 function modelForMode(mode) {
   if (mode === 'code-fast') return CODE_FAST.model;
   if (mode === 'max') return 'atris:max';
+  if (mode === 'rapid') return 'atris:rapid';
   return mode === 'fast' ? 'atris:fast' : 'atris:pro';
 }
 
@@ -120,7 +121,7 @@ function postTurnTimeoutMs(payload = {}, options = {}) {
   // AX postTurn is the tool-capable Atris2 path. Fast tool turns need the same
   // headroom as pro because the backend can spend long stretches inside tools
   // without SSE traffic. Plain tool-free one-shot fast chat stays at 60s.
-  if (model === 'atris:fast' && payloadCanRunTools(payload, options)) {
+  if ((model === 'atris:fast' || model === 'atris:rapid') && payloadCanRunTools(payload, options)) {
     timeoutMs = Math.max(timeoutMs, PRO_TURN_TIMEOUT_MS);
   }
   if (options.business || options.local) {
@@ -146,6 +147,7 @@ function formatSeconds(totalSeconds) {
 function tierLabel(mode) {
   if (mode === 'code-fast') return 'Atris Code Fast';
   if (mode === 'max') return 'Atris 2 Max';
+  if (mode === 'rapid') return 'Atris Rapid';
   if (mode === 'fast') return 'Atris 2 Fast';
   return 'Atris 2 Pro';
 }
@@ -154,7 +156,7 @@ function formatHeader({ mode = 'pro', cwd = process.cwd(), chat = false } = {},
   return [
     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) : '',
+    chat ? paint('shift-tab bypass · /auto /log /today /now /who · /fast /pro /max /rapid · exit to leave', [ANSI.muted], options) : '',
   ].filter(Boolean).join('\n');
 }
 
@@ -163,15 +165,16 @@ function formatUsage() {
     'ax - Atris local/code agent',
     '',
     'Usage:',
-    '  ax [--auto|--max|--pro|--fast|--code-fast] [--local|--cloud] <message>',
-    '  ax [--auto|--max|--pro|--fast|--code-fast] [--local|--cloud] --print <message>',
-    '  ax [--auto|--max|--pro|--fast|--code-fast] [--local|--cloud] --chat',
-    '  ax [--max|--pro|--fast] --business <slug> [<message>|--chat]',
-    '  ax [--max|--pro|--fast|--code-fast] --doctor',
+    '  ax [--auto|--max|--pro|--fast|--rapid|--code-fast] [--local|--cloud] <message>',
+    '  ax [--auto|--max|--pro|--fast|--rapid|--code-fast] [--local|--cloud] --print <message>',
+    '  ax [--auto|--max|--pro|--fast|--rapid|--code-fast] [--local|--cloud] --chat',
+    '  ax [--max|--pro|--fast|--rapid] --business <slug> [<message>|--chat]',
+    '  ax [--max|--pro|--fast|--rapid|--code-fast] --doctor',
     '  ax --approvals',
     '  ax --approve <approval-id>',
     '  ax --deny <approval-id>',
     '  ax --grant <approval-id>      approve and remember this exact command (this workspace)',
+    '  ax --auto-approve             chat session auto-approves safe git push',
     '  ax --grants                   list active permission grants',
     '  ax --sync-grants              push/pull grants with atrisos-web',
     '  ax --revoke-grant <grant-id>',
@@ -183,6 +186,7 @@ function formatUsage() {
     '  --max   hosted Atris 2, highest reasoning, slowest turns',
     '  --pro   hosted Atris 2, deeper tool loop',
     '  --fast  hosted Atris 2, faster low-latency turns',
+    '  --rapid  hosted Atris Rapid, cheapest chat and first-hop tools',
     '  --code-fast  Atris Code Fast public lane',
     '  --local opt into local backend/workspace tools',
     '  --cloud force authenticated cloud connectors/chat',
@@ -193,6 +197,7 @@ function formatUsage() {
     'Examples:',
     '  ax --pro find the config file and explain it',
     '  ax --fast what files are here',
+    '  ax --rapid --chat',
     '  ax --max refactor this module and verify the tests',
     '  ax --max --verify "npm test" fix the failing suite',
     '  ax --code-fast explain this error',
@@ -352,7 +357,9 @@ function buildRunProfile(options = {}) {
     ? 'Max workspace tool loop uses high reasoning effort'
     : mode === 'pro'
       ? 'Pro workspace tool loop uses API default medium'
-      : 'Fast workspace tool loop uses provider default';
+      : mode === 'rapid'
+        ? 'Rapid workspace tool loop uses thinking off'
+        : 'Fast workspace tool loop uses provider default';
   return {
     endpoint: backendUrl({ route }),
     mode,
@@ -404,6 +411,7 @@ async function buildRuntimeHealth(options = {}) {
   const data = healthRes.ok && healthRes.data && typeof healthRes.data === 'object' ? healthRes.data : {};
   const models = Array.isArray(data.models) ? data.models : [];
   const fast = models.find(row => row && row.id === 'atris:fast') || null;
+  const rapid = models.find(row => row && row.id === 'atris:rapid') || null;
   const status = Number(healthRes.status || 0);
   const authRequired = status === 401 || status === 403;
   return {
@@ -420,6 +428,10 @@ async function buildRuntimeHealth(options = {}) {
       ready: Boolean(fast && fast.ready),
       route_ready: Boolean(fast && fast.ready),
     },
+    rapid: {
+      ready: Boolean(rapid && rapid.ready),
+      route_ready: Boolean(rapid && rapid.ready),
+    },
     permissions: {
       approval_execution_path: APPROVAL_EXECUTE_PATH,
       ready: Boolean(healthRes.ok),
@@ -432,10 +444,12 @@ function formatRuntimeHealth(health, options = {}) {
   const backendReachable = health && health.backend && health.backend.reachable;
   const authRequired = health && health.backend && health.backend.auth_required;
   const fastReady = health && health.fast && health.fast.ready;
+  const rapidReady = health && health.rapid && health.rapid.ready;
   const permissionReady = health && health.permissions && health.permissions.ready;
   const rows = [
     ['backend', authRequired ? 'auth required' : backendReady ? 'ready' : backendReachable ? 'not ready' : 'offline'],
     ['fast', fastReady ? 'ready' : 'not ready'],
+    ['rapid', rapidReady ? 'ready' : 'not ready (backend has no WAFER_API_KEY)'],
     ['approvals', authRequired ? 'auth required' : permissionReady ? 'ready' : 'offline'],
   ];
   if (authRequired) {
@@ -450,6 +464,7 @@ 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;
+  if (normalizeMode(mode) === 'rapid' && health.rapid && health.rapid.ready === false) return false;
   return true;
 }
 
@@ -955,6 +970,7 @@ function resolveRoute(message, options = {}) {
 function normalizeMode(mode) {
   if (mode === 'code-fast' || mode === 'code') return 'code-fast';
   if (mode === 'max') return 'max';
+  if (mode === 'rapid') return 'rapid';
   return mode === 'fast' ? 'fast' : 'pro';
 }
 
@@ -1060,52 +1076,347 @@ function autoLaneForMessage(message, options = {}) {
   return picked;
 }
 
+function cycleApproveMode(mode) {
+  return String(mode) === 'auto' ? 'stage' : 'auto';
+}
+
+function approveModeTag(mode) {
+  return String(mode) === 'auto' ? 'bypass permissions' : '';
+}
+
+function nextApproveMode(arg, current) {
+  const want = String(arg || '').toLowerCase();
+  if (want === 'on' || want === 'bypass') return 'auto';
+  if (want === 'off' || want === 'ask') return 'stage';
+  return cycleApproveMode(current);
+}
+
 function formatPrompt(mode, options = {}) {
   if (!mode) return '› ';
   const tier = normalizeMode(mode);
   const label = paint(tier, [ANSI.bold, tierColor(tier)], options);
-  if (options.approveMode === 'auto') {
-    return `${label} ${paint('[auto-approve]', [ANSI.muted], options)} › `;
+  const tag = approveModeTag(options.approveMode);
+  if (tag) {
+    return `${label} ${paint(`[${tag}]`, [ANSI.muted], options)} › `;
   }
   return `${label} › `;
 }
 
-const TIER_COMMANDS = new Map([
-  ['/fast', 'fast'],
-  ['/pro', 'pro'],
-  ['/max', 'max'],
-]);
+function refreshReadlinePrompt(rl, prompt) {
+  if (!rl || typeof rl.setPrompt !== 'function') return;
+  rl.setPrompt(prompt);
+  if (typeof rl.prompt === 'function') rl.prompt(true);
+}
+
+function attachApproveModeHotkey(rl, session, getPrompt) {
+  if (!rl || typeof rl._ttyWrite !== 'function') return () => {};
+  const original = rl._ttyWrite.bind(rl);
+  rl._ttyWrite = (s, key) => {
+    if (key && key.name === 'tab' && key.shift && !key.ctrl && !key.meta) {
+      session.approveMode = cycleApproveMode(session.approveMode);
+      refreshReadlinePrompt(rl, getPrompt());
+      return;
+    }
+    return original(s, key);
+  };
+  return () => { rl._ttyWrite = original; };
+}
+
+const TIER_BLURBS = {
+  rapid: 'cheap chat and first-hop tools',
+  fast: 'quick answers, lowest latency',
+  pro: 'deeper tool loop for real work',
+  max: 'highest reasoning for the hardest jobs',
+};
+
+const CHAT_COMMANDS = Object.freeze([
+  { name: '/help', description: 'list all commands', type: 'help' },
+  { name: '/model', description: 'show the current lane and how to switch', type: 'model' },
+  { name: '/status', description: 'show runtime health', type: 'status' },
+  { name: '/fast', description: 'switch to quick answers with low latency', type: 'tier', mode: 'fast' },
+  { name: '/pro', description: 'switch to a deeper tool loop', type: 'tier', mode: 'pro' },
+  { name: '/max', description: 'switch to the highest reasoning lane', type: 'tier', mode: 'max' },
+  { name: '/rapid', description: 'switch to the cheapest chat lane', type: 'tier', mode: 'rapid' },
+  { name: '/new', description: 'start a new conversation', type: 'clear' },
+  { name: '/clear', description: 'reset the current conversation', type: 'clear' },
+  { name: '/context', description: 'show the conversation size', type: 'context' },
+  { name: '/log', description: 'append a note to today\'s journal', type: 'log' },
+  { name: '/today', description: 'show today\'s journal', type: 'today' },
+  { name: '/now', description: 'show the current priorities', type: 'now' },
+  { name: '/who', description: 'show the current lane', type: 'who' },
+  { name: '/auto', description: 'toggle safe git push approval', type: 'auto' },
+  { name: '/bypass', description: 'toggle the same safe approval mode', type: 'auto' },
+  { name: '/exit', description: 'leave the chat', type: 'exit' },
+  { name: '/quit', description: 'leave the chat', type: 'exit' },
+].map(command => Object.freeze(command)));
+
+const CHAT_COMMAND_BY_NAME = new Map(CHAT_COMMANDS.map(command => [command.name, command]));
+const TIER_COMMANDS = new Map(
+  CHAT_COMMANDS
+    .filter(command => command.type === 'tier')
+    .map(command => [command.name, command.mode])
+);
 
 function chatTierCommand(line) {
   return TIER_COMMANDS.get(String(line || '').trim().toLowerCase()) || null;
 }
 
-const CHAT_COMMANDS = [
-  ['/fast', 'quick answers, lowest latency'],
-  ['/pro', 'deeper tool loop for real work'],
-  ['/max', 'highest reasoning for the hardest jobs'],
-  ['/clear', 'wipe chat history and reset conversation id'],
-  ['/context', 'show turn count and rough token estimate'],
-  ['/help', 'show this menu'],
-  ['exit', 'leave chat'],
-];
-
-function chatMenu(options = {}) {
-  return CHAT_COMMANDS
-    .map(([name, desc]) => {
-      const tier = TIER_COMMANDS.get(name);
+function chatMenu(options = {}, commands = CHAT_COMMANDS) {
+  const width = commands.reduce((max, command) => Math.max(max, command.name.length), 0);
+  return commands
+    .map(command => {
+      const tier = TIER_COMMANDS.get(command.name);
       const color = tier ? tierColor(tier) : ANSI.accent;
-      return `  ${paint(name.padEnd(6), [color], options)}  ${paint(desc, [ANSI.muted], options)}`;
+      return `  ${paint(command.name.padEnd(width), [color], options)}  ${paint(command.description, [ANSI.muted], options)}`;
     })
     .join('\n');
 }
 
+function filterChatCommands(line) {
+  const text = String(line || '');
+  if (!text.startsWith('/') || /\s/.test(text)) return [];
+  const query = text.toLowerCase();
+  return CHAT_COMMANDS.filter(command => command.name.startsWith(query));
+}
+
+function parseChatSlash(line) {
+  const trimmed = String(line || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [raw, ...rest] = trimmed.split(/\s+/);
+  return {
+    name: raw.toLowerCase(),
+    arg: rest.join(' ').trim(),
+    raw: trimmed,
+  };
+}
+
+function todayJournalPath(cwd = process.cwd(), date = new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const stamp = `${year}-${month}-${day}`;
+  return {
+    file: path.join(cwd, 'atris', 'logs', String(year), `${stamp}.md`),
+    stamp,
+    time: `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`,
+  };
+}
+
+function readTextTail(file, maxLines = 24) {
+  if (!fs.existsSync(file)) return null;
+  const lines = fs.readFileSync(file, 'utf8').split(/\r?\n/);
+  return lines.slice(Math.max(0, lines.length - maxLines)).join('\n').trimEnd();
+}
+
+function readTextHead(file, maxLines = 24) {
+  if (!fs.existsSync(file)) return null;
+  return fs.readFileSync(file, 'utf8').split(/\r?\n/).slice(0, maxLines).join('\n').trimEnd();
+}
+
+function appendChatJournal(cwd, note, date = new Date()) {
+  const { file, stamp, time } = todayJournalPath(cwd, date);
+  const text = String(note || '').replace(/\s+/g, ' ').trim();
+  if (!text) return { ok: false, error: 'Usage: /log <what happened>' };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const block = `\n## ${time} · Chat\n\n- ${text}\n`;
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, `# ${stamp}\n${block}`);
+  } else {
+    let existing = fs.readFileSync(file, 'utf8');
+    if (existing && !existing.endsWith('\n')) existing += '\n';
+    fs.writeFileSync(file, existing + block);
+  }
+  return { ok: true, file: path.relative(cwd, file) };
+}
+
+function runChatSlash(line, options = {}) {
+  const parsed = parseChatSlash(line);
+  if (!parsed) return null;
+  const cwd = options.cwd || process.cwd();
+  const mode = normalizeMode(options.mode || 'fast');
+  if (parsed.name === '/') {
+    return { type: 'help', output: chatMenu(options) };
+  }
+  const command = CHAT_COMMAND_BY_NAME.get(parsed.name);
+  if (!command) {
+    return { type: 'unknown', output: `unknown command ${parsed.name}\n${chatMenu(options)}` };
+  }
+  if (command.type === 'help') {
+    return { type: 'help', output: chatMenu(options) };
+  }
+  if (command.type === 'tier') {
+    return { type: 'tier', mode: command.mode, output: `· ${tierLabel(command.mode)}` };
+  }
+  if (command.type === 'exit') {
+    return { type: 'exit', output: '' };
+  }
+  if (command.type === 'clear') {
+    return { type: 'clear', output: 'context cleared' };
+  }
+  if (command.type === 'context') {
+    const ctx = estimateHistoryContext(options.history || []);
+    return {
+      type: 'context',
+      output: `· ${ctx.turns} turn${ctx.turns === 1 ? '' : 's'} · ~${ctx.chars} chars · ~${ctx.tokens} tokens`,
+    };
+  }
+  if (command.type === 'model') {
+    return {
+      type: 'model',
+      output: `· current lane: ${tierLabel(mode)} · switch with /fast /pro /max /rapid`,
+    };
+  }
+  if (command.type === 'status') {
+    return { type: 'status', output: '' };
+  }
+  if (command.type === 'who') {
+    return { type: 'who', output: `· ${tierLabel(mode)} · ${TIER_BLURBS[mode] || 'chat'}` };
+  }
+  if (command.type === 'auto') {
+    const next = nextApproveMode(parsed.arg, options.approveMode);
+    return {
+      type: 'auto',
+      approveMode: next,
+      output: next === 'auto'
+        ? '· bypass permissions on · safe git push this session, not force and not mail'
+        : '· bypass permissions off',
+    };
+  }
+  if (command.type === 'log') {
+    const result = appendChatJournal(cwd, parsed.arg, options.now);
+    if (!result.ok) return { type: 'log', output: result.error };
+    return { type: 'log', output: `· logged to ${result.file}` };
+  }
+  if (command.type === 'today') {
+    const { file } = todayJournalPath(cwd, options.now);
+    const text = readTextTail(file);
+    return {
+      type: 'today',
+      output: text || `· no journal yet at ${path.relative(cwd, file)}`,
+    };
+  }
+  if (command.type === 'now') {
+    const file = path.join(cwd, 'atris', 'now.md');
+    const text = readTextHead(file);
+    return { type: 'now', output: text || '· atris/now.md is missing' };
+  }
+  return { type: 'unknown', output: `unknown command ${parsed.name}\n${chatMenu(options)}` };
+}
+
 function chatCompleter(line) {
-  const trimmed = String(line || '').trimStart().toLowerCase();
-  if (!trimmed.startsWith('/')) return [[], line];
-  const names = CHAT_COMMANDS.map(([name]) => name).filter(name => name.startsWith('/'));
-  const hits = names.filter(name => name.startsWith(trimmed));
-  return [hits.length ? hits : names, trimmed];
+  const text = String(line || '');
+  const hits = filterChatCommands(text).map(command => command.name);
+  return [hits, text];
+}
+
+function attachSlashMenu(rl, output, options = {}) {
+  if (!rl || !output || !output.isTTY || typeof output.write !== 'function' || typeof rl._ttyWrite !== 'function') {
+    return { clear() {}, render() {}, detach() {} };
+  }
+  const original = rl._ttyWrite.bind(rl);
+  let visibleRows = 0;
+
+  const clear = () => {
+    if (!visibleRows) return;
+    output.write('\x1b7');
+    for (let index = 0; index < visibleRows; index += 1) {
+      output.write('\x1b[1B\r\x1b[2K');
+    }
+    output.write('\x1b8');
+    visibleRows = 0;
+  };
+
+  const render = () => {
+    clear();
+    if (typeof options.isActive === 'function' && !options.isActive()) return;
+    const matches = filterChatCommands(rl.line);
+    if (!matches.length) return;
+    const rows = chatMenu(output, matches).split('\n');
+    output.write('\x1b7');
+    for (const row of rows) output.write(`\r\n${row}`);
+    output.write('\x1b8');
+    visibleRows = rows.length;
+  };
+
+  const wrapped = (s, key) => {
+    const submitsLine = key && (key.name === 'return' || key.name === 'enter');
+    if (submitsLine) clear();
+    const result = original(s, key);
+    if (!submitsLine) render();
+    return result;
+  };
+  rl._ttyWrite = wrapped;
+
+  return {
+    clear,
+    render,
+    detach() {
+      clear();
+      if (rl._ttyWrite === wrapped) rl._ttyWrite = original;
+    },
+  };
+}
+
+function attachChatCtrlC(rl, options = {}) {
+  if (!rl || typeof rl.on !== 'function') return () => {};
+  const output = options.output || process.stdout;
+  const exitWindowMs = Number(options.exitWindowMs) || 2000;
+  let lastEmptyPressAt = 0;
+  let expiryTimer = null;
+
+  const resetExitWindow = () => {
+    lastEmptyPressAt = 0;
+    if (expiryTimer) clearTimeout(expiryTimer);
+    expiryTimer = null;
+  };
+
+  const clearDraft = () => {
+    if (typeof options.clearMenu === 'function') options.clearMenu();
+    if (typeof rl.write === 'function') {
+      rl.write(null, { ctrl: true, name: 'u' });
+      rl.write(null, { ctrl: true, name: 'k' });
+      return;
+    }
+    rl.line = '';
+    rl.cursor = 0;
+    if (typeof rl._refreshLine === 'function') rl._refreshLine();
+  };
+
+  const onSigint = () => {
+    if (typeof options.isTurnInFlight === 'function' && options.isTurnInFlight()) {
+      resetExitWindow();
+      if (typeof options.interruptTurn === 'function') options.interruptTurn();
+      return;
+    }
+    if (String(rl.line || '').length > 0) {
+      resetExitWindow();
+      clearDraft();
+      return;
+    }
+
+    const now = Date.now();
+    if (lastEmptyPressAt && now - lastEmptyPressAt <= exitWindowMs) {
+      resetExitWindow();
+      if (typeof options.exit === 'function') options.exit();
+      return;
+    }
+
+    lastEmptyPressAt = now;
+    if (typeof options.clearMenu === 'function') options.clearMenu();
+    output.write('\npress ctrl-c again to exit\n');
+    if (typeof rl._refreshLine === 'function') rl._refreshLine();
+    expiryTimer = setTimeout(() => {
+      lastEmptyPressAt = 0;
+      expiryTimer = null;
+    }, exitWindowMs);
+    if (typeof expiryTimer.unref === 'function') expiryTimer.unref();
+  };
+
+  rl.on('SIGINT', onSigint);
+  return () => {
+    resetExitWindow();
+    if (typeof rl.removeListener === 'function') rl.removeListener('SIGINT', onSigint);
+  };
 }
 
 function formatWorkingLine(ms, verb, frame) {
@@ -2152,19 +2463,49 @@ async function approveWorkspaceApproval(ref, options = {}) {
 // A persistent grant (ax --grant) lets an exact approved command pattern
 // redeem itself on later turns instead of re-asking; anything unmatched
 // falls through to the normal hint. Store: ~/.atris/permission-grants.json.
+function isSafeGitPushApproval(record) {
+  const action = String((record && record.action_type) || '');
+  const payload = (record && record.payload && typeof record.payload === 'object') ? record.payload : {};
+  if (action === 'git_push') {
+    if (payload.force || payload.force_with_lease || payload['force-with-lease']) return false;
+    const remote = String(payload.remote || 'origin');
+    const branch = String(payload.branch || 'HEAD');
+    if (!/^[A-Za-z0-9._\/-]+$/.test(remote) || !/^[A-Za-z0-9._\/-]+$/.test(branch)) return false;
+    return true;
+  }
+  if (action === 'local_command') {
+    const command = String(payload.command || '').trim();
+    if (!/^git\s+push\b/i.test(command)) return false;
+    if (/\s(-f|--force|--force-with-lease)\b/i.test(command)) return false;
+    // Flags are not the only force path: a "+refspec" force-pushes, ":branch"
+    // and --delete delete remote refs, --mirror/--prune force-prune them.
+    if (/\s(--delete|-d|--mirror|--prune)\b/i.test(command)) return false;
+    if (/\s\+\S/.test(command)) return false;
+    if (/\s:\S/.test(command)) return false;
+    return permissionGrants.commandIsGrantable(command).ok;
+  }
+  return false;
+}
+
 async function autoRedeemGrantedApprovals(cwd, sinceMs, options = {}) {
   const redeemed = [];
   for (const item of pendingWorkspaceApprovalsSince(cwd, sinceMs)) {
     const record = item.record;
-    if (String(record.action_type || '') !== 'local_command') continue;
     const command = record.payload && record.payload.command;
-    const grant = permissionGrants.matchGrant({ command, workspaceRoot: cwd });
-    if (!grant) continue;
+    const grant = String(record.action_type || '') === 'local_command'
+      ? permissionGrants.matchGrant({ command, workspaceRoot: cwd })
+      : null;
+    const sessionAuto = options.approveMode === 'auto' && isSafeGitPushApproval(record);
+    if (!grant && !sessionAuto) continue;
     const output = options.output || process.stdout;
-    output.write(`${formatAuxRow('grant', `auto-approved via ${grant.grant_id}: ${grant.pattern.display}`, output)}\n`);
+    const why = grant
+      ? `auto-approved via ${grant.grant_id}: ${grant.pattern.display}`
+      : `auto-approved ${record.action_type} this session`;
+    output.write(`${formatAuxRow('grant', why, output)}\n`);
     try {
-      await approveWorkspaceApproval(record.approval_id, { ...options, cwd, output });
-      permissionGrants.recordUse(grant.grant_id);
+      const approve = options.approveFn || approveWorkspaceApproval;
+      await approve(record.approval_id, { ...options, cwd, output });
+      if (grant) permissionGrants.recordUse(grant.grant_id);
       redeemed.push(record.approval_id);
     } catch {
       // Redemption failed: leave the artifact pending so the hint still shows.
@@ -2614,7 +2955,7 @@ function buildPayload(message, options = {}) {
   const payload = {
     message: buildMessage(message, options.history || []),
     model: modelForMode(mode),
-    max_turns: local ? (mode === 'fast' ? 16 : 24) : 1,
+    max_turns: local ? (mode === 'rapid' ? 6 : mode === 'fast' ? 16 : 24) : 1,
     verify_command: verifyCommand || 'true',
     local_tools: [backendApiToolDescriptor()]
   };
@@ -2811,6 +3152,16 @@ function handleEvent(event, state, output) {
   }
 }
 
+function turnInterruptedError() {
+  const error = new Error('turn interrupted');
+  error.name = 'AbortError';
+  return error;
+}
+
+function isTurnInterruptedError(error) {
+  return Boolean(error && (error.name === 'AbortError' || error.code === 'ABORT_ERR'));
+}
+
 async function postTurn(message, options = {}) {
   let route = options.business ? 'local' : resolveRoute(message, options);
   if (route === 'local' && !options.business && options.route !== 'local' && !options.forceLocal
@@ -2883,6 +3234,7 @@ async function postTurn(message, options = {}) {
 
   return new Promise((resolve, reject) => {
     let settled = false;
+    let abortListener = null;
     const startedAt = Date.now();
     state.progress = createProgressReporter(output, options);
     state.progress.start();
@@ -2890,6 +3242,7 @@ async function postTurn(message, options = {}) {
     const finish = (error, value) => {
       if (settled) return;
       settled = true;
+      if (abortListener && options.signal) options.signal.removeEventListener('abort', abortListener);
       if (state.progress) state.progress.stop();
       state.progress = null;
       state.durationMs = Date.now() - startedAt;
@@ -2925,7 +3278,13 @@ async function postTurn(message, options = {}) {
           const block = buffer.slice(0, boundary);
           buffer = buffer.slice(boundary + 2);
           try {
-            handleEvent(parseSseBlock(block), state, output);
+            const event = parseSseBlock(block);
+            handleEvent(event, state, output);
+            if (event && event.type === 'result') {
+              flushPendingText(state, output);
+              if (state.resultOutput) state.output = state.resultOutput;
+              finish(null, state);
+            }
           } catch (error) {
             state.errors.push(`bad_sse_event: ${error.message}`);
           }
@@ -2972,6 +3331,17 @@ async function postTurn(message, options = {}) {
       finish(new Error(`Request timeout after ${timeoutMs / 1000}s`));
       req.destroy();
     });
+    if (options.signal) {
+      abortListener = () => {
+        finish(turnInterruptedError());
+        req.destroy();
+      };
+      if (options.signal.aborted) {
+        abortListener();
+        return;
+      }
+      options.signal.addEventListener('abort', abortListener, { once: true });
+    }
     req.write(postData);
     req.end();
   });
@@ -3010,6 +3380,7 @@ async function postCodeFastTurn(message, options = {}) {
 
   return new Promise((resolve, reject) => {
     let settled = false;
+    let abortListener = null;
     const startedAt = Date.now();
     state.progress = createProgressReporter(output, options);
     state.progress.start();
@@ -3017,6 +3388,7 @@ async function postCodeFastTurn(message, options = {}) {
     const finish = (error, value) => {
       if (settled) return;
       settled = true;
+      if (abortListener && options.signal) options.signal.removeEventListener('abort', abortListener);
       if (state.progress) state.progress.stop();
       state.progress = null;
       state.durationMs = Date.now() - startedAt;
@@ -3081,6 +3453,17 @@ async function postCodeFastTurn(message, options = {}) {
       finish(new Error(`Request timeout after ${timeoutMs / 1000}s`));
       req.destroy();
     });
+    if (options.signal) {
+      abortListener = () => {
+        finish(turnInterruptedError());
+        req.destroy();
+      };
+      if (options.signal.aborted) {
+        abortListener();
+        return;
+      }
+      options.signal.addEventListener('abort', abortListener, { once: true });
+    }
     req.write(postData);
     req.end();
   });
@@ -3145,8 +3528,11 @@ async function chat(options = {}) {
   const history = [];
   let lastCompactionNotice = 0;
   let conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
-  const session = { approveMode: 'stage' };
+  const session = { approveMode: options.autoApprove || options.approveMode === 'auto' ? 'auto' : 'stage' };
   let turnInFlight = false;
+  let activeTurnController = null;
+  let slashMenu = null;
+  let pendingApprovalAbort = null;
 
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
   if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
@@ -3170,7 +3556,18 @@ async function chat(options = {}) {
       return true;
     }
     output.write(`${formatRuntimeHealth(health, output)}\n\n`);
-    output.write(`${formatBackendHint({ route: endpointRoute })}\n`);
+    // A reachable backend with one not-ready lane is a missing provider key,
+    // not a dead cloud; saying "cloud did not respond" here sent live debugging
+    // at the network when the fix was an env var (seen live 2026-08-16).
+    const laneKey = normalizeMode(mode) === 'rapid' ? 'rapid' : normalizeMode(mode) === 'fast' ? 'fast' : null;
+    const laneNotReady = laneKey && health && health[laneKey] && health[laneKey].ready === false;
+    if (health && health.backend && health.backend.ready && laneNotReady) {
+      const keyName = laneKey === 'rapid' ? 'WAFER_API_KEY' : 'FIREWORKS_API_KEY';
+      const where = endpointRoute === 'local' ? `${keyName} to backend/.env and restart it` : `${keyName} to the cloud backend env and redeploy`;
+      output.write(`The ${laneKey} model has no key on the ${endpointRoute} backend. Add ${where}, or switch lanes with /fast.\n`);
+    } else {
+      output.write(`${formatBackendHint({ route: endpointRoute })}\n`);
+    }
     output.write(`${formatDoneLine(Date.now() - startedAt)}\n\n`);
     return false;
   };
@@ -3180,34 +3577,30 @@ async function chat(options = {}) {
     if (!trimmed) return false;
     if (EXIT_WORDS.has(trimmed.toLowerCase())) return true;
 
-    if (trimmed === '/' || trimmed.toLowerCase() === '/help') {
-      output.write(`${chatMenu(output)}\n\n`);
-      return false;
-    }
-
-    const tier = chatTierCommand(trimmed);
-    if (tier) {
-      mode = tier;
+    const slash = runChatSlash(trimmed, { cwd, mode, history, approveMode: session.approveMode, isTTY: output.isTTY });
+    if (slash) {
+      if (slash.type === 'exit') return true;
+      if (slash.mode) mode = slash.mode;
+      if (slash.approveMode) session.approveMode = slash.approveMode;
+      if (slash.type === 'clear') {
+        history.length = 0;
+        conversationId = `ax-${process.pid}-${Date.now().toString(36)}`;
+      }
+      if (slash.type === 'status') {
+        const healthRoute = options.business
+          ? 'cloud'
+          : options.route === 'local' || options.forceLocal
+            ? 'local'
+            : 'cloud';
+        const health = options.runtimeHealth
+          ? await Promise.resolve(options.runtimeHealth({ mode, route: healthRoute }))
+          : await buildRuntimeHealth({ timeoutMs: options.preflightTimeoutMs || 1200, route: healthRoute });
+        slash.output = formatRuntimeHealth(health, output);
+      }
       if (logger) logger.write(`${trimmed}\n`);
-      output.write(`${paint(`· ${tierLabel(mode)}`, [tierColor(mode)], output)}\n\n`);
-      return false;
-    }
-
-    if (trimmed === '/clear') {
-      history.length = 0;
-      conversationId = `ax-${process.pid}-${Date.now().toString(36)}`;
-      output.write(`${paint('context cleared', [ANSI.muted], output)}\n\n`);
-      return false;
-    }
-
-    if (trimmed === '/context') {
-      const ctx = estimateHistoryContext(history);
-      output.write(`${paint(`· ${ctx.turns} turn${ctx.turns === 1 ? '' : 's'} · ~${ctx.chars} chars · ~${ctx.tokens} tokens`, [ANSI.muted], output)}\n\n`);
-      return false;
-    }
-
-    if (trimmed.startsWith('/')) {
-      output.write(`${chatMenu(output)}\n\n`);
+      const color = slash.mode ? [tierColor(slash.mode)] : [ANSI.muted];
+      const preservesOwnFormatting = slash.type === 'help' || slash.type === 'status';
+      output.write(`${preservesOwnFormatting ? slash.output : paint(slash.output, color, output)}\n\n`);
       return false;
     }
 
@@ -3322,6 +3715,9 @@ async function chat(options = {}) {
       output.write(`${paint(`· context: ${compactedTurns} earlier turn${compactedTurns === 1 ? '' : 's'} compacted into a digest`, [ANSI.muted], output)}\n`);
     }
     let result;
+    activeTurnController = new AbortController();
+    turnInFlight = true;
+    if (slashMenu) slashMenu.clear();
     try {
       result = await turnFunction(trimmed, {
         mode,
@@ -3338,6 +3734,7 @@ async function chat(options = {}) {
         apiRequestJson: options.apiRequestJson,
         loadCredentials: options.loadCredentials,
         getApiBaseUrl: options.getApiBaseUrl,
+        signal: activeTurnController.signal,
       });
       appendAutoOutcome(autoPick, {
         ok: true,
@@ -3345,6 +3742,10 @@ async function chat(options = {}) {
         durationMs: Number(result && result.durationMs) || (Date.now() - turnStartedAt),
       });
     } catch (error) {
+      if (isTurnInterruptedError(error)) {
+        output.write(`${paint('Interrupted.', [ANSI.muted], output)}\n\n`);
+        return false;
+      }
       appendAutoOutcome(autoPick, {
         ok: false,
         model: modelForMode(mode),
@@ -3352,6 +3753,16 @@ async function chat(options = {}) {
         error: String((error && error.message) || error),
       });
       throw error;
+    } finally {
+      turnInFlight = false;
+      activeTurnController = null;
+      // A turn that ends (abort, timeout, stream error) with an approval
+      // question still open must cancel it: an orphaned rl.question makes
+      // readline silently drop every later question and the chat goes dead.
+      if (pendingApprovalAbort) {
+        try { pendingApprovalAbort.abort(); } catch {}
+        pendingApprovalAbort = null;
+      }
     }
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
@@ -3361,7 +3772,14 @@ async function chat(options = {}) {
         output,
         ...(options.postApproval ? { postApproval: options.postApproval } : {}),
       });
-    if (!options.turnFunction) writeWorkspaceApprovalHints(cwd, turnStartedAt, output);
+    if (!options.turnFunction) {
+      await autoRedeemGrantedApprovals(cwd, turnStartedAt, {
+        mode,
+        output,
+        approveMode: session.approveMode,
+      });
+      writeWorkspaceApprovalHints(cwd, turnStartedAt, output);
+    }
     output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n`);
     const goalLine = options.turnFunction ? '' : formatGoalStatusLine(currentAtrisGoal(cwd), output);
     if (goalLine) output.write(`${goalLine}\n`);
@@ -3401,15 +3819,75 @@ async function chat(options = {}) {
   }
 
   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;
+  if (!options.approveBackendApi) {
+    // Mid-turn approvals must reuse the chat's readline: a second interface on
+    // the same stdin double-consumes keypresses and corrupts both prompts.
+    // The question is abortable so an interrupted or failed turn cancels it
+    // (deny by default) instead of leaving readline holding a dead callback.
+    // The approval question text is already written by the caller.
+    options.approveBackendApi = () => new Promise(resolve => {
+      const controller = new AbortController();
+      pendingApprovalAbort = controller;
+      const settle = answer => {
+        if (pendingApprovalAbort === controller) pendingApprovalAbort = null;
+        resolve(answer);
+      };
+      controller.signal.addEventListener('abort', () => settle(false), { once: true });
+      try {
+        rl.question('', { signal: controller.signal }, settle);
+      } catch {
+        settle(false);
+      }
+    });
+  }
+  const promptOptions = () => ({ isTTY: baseOutput.isTTY, approveMode: session.approveMode });
+  const detachHotkey = attachApproveModeHotkey(rl, session, () => formatPrompt(mode, promptOptions()));
+  slashMenu = attachSlashMenu(rl, baseOutput, { isActive: () => !turnInFlight });
+  const exitSignal = Symbol('chat exit');
+  let pendingAsk = null;
+  const requestExit = () => {
+    if (pendingAsk) pendingAsk(exitSignal);
+  };
+  const detachCtrlC = attachChatCtrlC(rl, {
+    output: baseOutput,
+    clearMenu: () => slashMenu.clear(),
+    isTurnInFlight: () => turnInFlight,
+    interruptTurn: () => {
+      if (activeTurnController) activeTurnController.abort();
+    },
+    exit: requestExit,
+  });
+  const onClose = () => requestExit();
+  rl.on('close', onClose);
+  const ask = () => new Promise(resolve => {
+    let settled = false;
+    const settle = value => {
+      if (settled) return;
+      settled = true;
+      if (pendingAsk === settle) pendingAsk = null;
+      resolve(value);
+    };
+    pendingAsk = settle;
+    try {
+      rl.question(formatPrompt(mode, promptOptions()), settle);
+    } catch (_) {
+      settle(exitSignal);
     }
+  });
+
+  try {
+    while (true) {
+      const line = await ask();
+      if (line === exitSignal || await runLine(line)) break;
+    }
+  } finally {
+    detachCtrlC();
+    slashMenu.detach();
+    detachHotkey();
+    rl.removeListener('close', onClose);
+    if (!rl.closed) rl.close();
+    if (logger) logger.close(0);
   }
-  if (logger) logger.close(0);
 }
 
 function printBackendHint(options = {}) {
@@ -4170,11 +4648,13 @@ async function main() {
     ? 'code-fast'
     : args.includes('--max')
       ? 'max'
-      : args.includes('--fast')
-        ? 'fast'
-        : args.includes('--pro')
-          ? 'pro'
-          : null;
+      : args.includes('--rapid')
+        ? 'rapid'
+        : args.includes('--fast')
+          ? 'fast'
+          : args.includes('--pro')
+            ? 'pro'
+            : null;
   const autoEnabled = args.includes('--auto') && !explicitLane;
   let mode = explicitLane || 'pro';
   const doctor = args.includes('--doctor');
@@ -4210,6 +4690,9 @@ async function main() {
   const listGrants = args.includes('--grants');
   if (listGrants) args.splice(args.indexOf('--grants'), 1);
 
+  const autoApprove = args.includes('--auto-approve');
+  if (autoApprove) args.splice(args.indexOf('--auto-approve'), 1);
+
   const syncGrantsFlag = args.includes('--sync-grants');
   if (syncGrantsFlag) args.splice(args.indexOf('--sync-grants'), 1);
 
@@ -4237,7 +4720,7 @@ async function main() {
 
   const route = forceCloud ? 'cloud' : forceLocal ? 'local' : 'auto';
   const prompt = args
-    .filter(arg => !['--auto', '--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--approvals', '--self-test', '--benchmark', '--print', '--headless', '--local', '--cloud', '--help', '-h'].includes(arg))
+    .filter(arg => !['--auto', '--auto-approve', '--max', '--fast', '--rapid', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--approvals', '--self-test', '--benchmark', '--print', '--headless', '--local', '--cloud', '--help', '-h'].includes(arg))
     .join(' ')
     .trim();
 
@@ -4398,12 +4881,17 @@ async function main() {
           autoPick,
         })
         : { ok: false, model: modelForMode(mode), output: '', durationMs: 0, error: 'missing prompt' };
-      console.log(JSON.stringify(payload));
-      process.exit(payload.ok ? 0 : 1);
+      // Drain stdout before exiting: process.exit right after a large write
+      // truncates piped output at the 64KB pipe buffer (same class as BCK-1306).
+      const code = payload.ok ? 0 : 1;
+      process.exitCode = code;
+      process.stdout.write(`${JSON.stringify(payload)}\n`, () => process.exit(code));
+      setTimeout(() => process.exit(code), 3000).unref();
+      return;
     }
 
     if (!prompt || args.includes('--chat')) {
-      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify, auto: autoEnabled });
+      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify, auto: autoEnabled, autoApprove });
       return;
     }
 
@@ -4437,7 +4925,11 @@ async function main() {
     // A one-shot has no next turn, so "reply yes to approve" is a dead end;
     // granted patterns redeem themselves, everything else gets the exact
     // redeem command for what the turn staged on disk.
-    await autoRedeemGrantedApprovals(process.cwd(), turnStartedAt, { mode, output: process.stdout });
+    await autoRedeemGrantedApprovals(process.cwd(), turnStartedAt, {
+      mode,
+      output: process.stdout,
+      approveMode: autoApprove ? 'auto' : undefined,
+    });
     writeWorkspaceApprovalHints(process.cwd(), turnStartedAt, process.stdout);
     console.log('');
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
@@ -4472,6 +4964,7 @@ module.exports = {
   approveStoredApproval,
   approveWorkspaceApproval,
   autoRedeemGrantedApprovals,
+  isSafeGitPushApproval,
   findWorkspaceApproval,
   listWorkspaceApprovals,
   pendingWorkspaceApprovalsSince,
@@ -4487,9 +4980,17 @@ module.exports = {
   buildConnectionContext,
   buildRunProfile,
   chat,
+  appendChatJournal,
+  attachApproveModeHotkey,
+  attachChatCtrlC,
+  attachSlashMenu,
   chatCompleter,
   chatMenu,
   chatTierCommand,
+  cycleApproveMode,
+  filterChatCommands,
+  parseChatSlash,
+  runChatSlash,
   codeFastWorkspaceNotice,
   creditsFromState,
   codeFastBaseUrl,