atris 3.31.0 → 3.33.3

package/ax

@@ -306,6 +306,20 @@ function formatRunProfile(profile, options = {}) {
   return rows.map(([label, value]) => formatAuxRow(label, value, options)).join('\n');
 }
 
+// Auto-routed local turns must never die on a missing local backend — a
+// consumer machine without the launchd service gets a degraded cloud chat
+// turn, not ECONNREFUSED. Probed once per process (REPL lines reuse it).
+// Explicit --local skips the downgrade so devs see the real error. Interim
+// guard until the cloud relay executes workspace tools in-process and
+// consumers stop needing a local backend at all.
+let _localBackendUp = null;
+async function localBackendReachable() {
+  if (_localBackendUp !== null) return _localBackendUp;
+  const res = await requestJson(ATRIS2_HEALTH_PATH, { timeoutMs: 1200, route: 'local' });
+  _localBackendUp = Boolean(res.ok || Number(res.status || 0) > 0);
+  return _localBackendUp;
+}
+
 async function buildRuntimeHealth(options = {}) {
   const route = options.route === 'local' || options.forceLocal ? 'local' : 'cloud';
   const healthRes = options.healthRes
@@ -621,9 +635,49 @@ 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);
 }
 
+// Walk up from cwd looking for a workspace marker (.git or atris/ or atris.md).
+// The process.cwd() answer is cached — resolveRoute runs per chat line — but an
+// explicit startDir (callers pass their own cwd) is always checked fresh.
+let _workspaceCwd = null;
+function insideWorkspaceCwd(startDir) {
+  const explicit = typeof startDir === 'string' && startDir.length > 0;
+  if (!explicit && _workspaceCwd !== null) return _workspaceCwd;
+  let dir = explicit ? startDir : process.cwd();
+  let found = false;
+  for (let i = 0; i < 24; i += 1) {
+    if (fs.existsSync(path.join(dir, '.git')) || fs.existsSync(path.join(dir, 'atris.md')) || fs.existsSync(path.join(dir, 'atris'))) {
+      found = true;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!explicit) _workspaceCwd = found;
+  return found;
+}
+
 function resolveRoute(message, options = {}) {
   if (options.route === 'local' || options.forceLocal) return 'local';
   if (options.route === 'cloud' || options.forceCloud) return 'cloud';
+  // Workspace standard v2 (2026-07-02, supersedes intent routing): inside a
+  // workspace, tools are ALWAYS attached and the model decides whether to use
+  // them — the Claude Code / Codex shape. v1 guessed intent with regexes and
+  // lost three times in one day ("in scripts/fast-coach/tick.mjs, what does
+  // SLOW_MS control?", "what did Atris ship last night?", "find it lol" — all
+  // tool-less misses that told the user to paste files they were sitting on).
+  // Measured cost of always-tools: pure math 3s vs 2s; and "plan my morning"
+  // through the tool lane reads the real task board instead of guessing.
+  // Non-workspace cwds stay pure cloud (the privacy line); explicit flags
+  // always win. One carve-out: GitHub-connector phrasing prefers the cloud
+  // GitHub API lane unless it names local-checkout work.
+  const text = String(message || '');
+  // Local-checkout work includes every git mutation verb: cloud chat can only
+  // read the GitHub connector, so "do a quick github push" through the cloud
+  // lane dead-ends in a write-blocked upsell (live miss 2026-07-02). Inside a
+  // workspace the local tool loop just runs git.
+  if (/\bgithub\b/i.test(text) && !/\b(commits?|branch(?:es)?|checkout|merge|rebase|changes?|diff|push(?:es|ed|ing)?|pull(?:s|ed|ing)?|fetch|clone|stash|tags?)\b/i.test(text)) return 'cloud';
+  if (insideWorkspaceCwd(options.cwd)) return 'local';
   return 'cloud';
 }
 
@@ -808,6 +862,19 @@ function formatAtrisGoal(goal) {
   ].filter(Boolean).join('\n');
 }
 
+function formatGoalStatusLine(goal, options = {}) {
+  if (!goal || !goal.objective) return '';
+  const status = String(goal.mission_status || '').toLowerCase();
+  if (!['active', 'running', 'planning', 'in_progress', 'ready'].includes(status)) return '';
+  const elapsed = goalElapsedSeconds(goal);
+  const objective = String(goal.objective).length > 64
+    ? `${String(goal.objective).slice(0, 61)}...`
+    : String(goal.objective);
+  const parts = [`goal: ${objective}`, status];
+  if (elapsed !== null) parts.push(`${formatSeconds(elapsed)} in`);
+  return paint(`· ${parts.join(' · ')}`, [ANSI.muted], options);
+}
+
 function writeAtrisGoalBanner(output, cwd = process.cwd()) {
   const text = formatAtrisGoal(currentAtrisGoal(cwd));
   if (!text) return false;
@@ -883,28 +950,176 @@ function resetMarkdownState(state) {
   state.markdownMode = 'normal';
   state.markdownBuffer = '';
   state.markdownCarry = '';
+  state.markdownFence = false;
+  state.markdownTable = [];
+  state.markdownLine = '';
+  state.markdownLineMode = 'start';
 }
 
 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.markdownFence !== 'boolean') state.markdownFence = false;
+  if (!Array.isArray(state.markdownTable)) state.markdownTable = [];
+  if (typeof state.markdownLine !== 'string') state.markdownLine = '';
+  if (!state.markdownLineMode) state.markdownLineMode = 'start';
+}
+
+function renderInlineMarkdown(text, options = {}) {
+  let rendered = String(text || '');
+  const codeSpans = [];
+  rendered = rendered.replace(/`([^`\n]+)`/g, (_, code) => {
+    const token = `\u0000CODE${codeSpans.length}\u0000`;
+    codeSpans.push(code);
+    return token;
+  });
+  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(/\u0000CODE(\d+)\u0000/g, (_, index) => paint(codeSpans[Number(index)] || '', [ANSI.accent], options));
+  return rendered;
 }
 
+function renderMarkdownTable(lines, options = {}) {
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = String(line || '').trim().replace(/^\|/, '').replace(/\|$/, '');
+    const cells = trimmed.split('|').map(cell => cell.trim());
+    if (cells.length && cells.every(cell => /^:?-{2,}:?$/.test(cell))) continue;
+    rows.push(cells);
+  }
+  if (!rows.length) return '';
+  const width = Math.max(...rows.map(row => row.length));
+  const plain = value => String(value || '').replace(/\x1b\[[0-9;]*m/g, '');
+  const rendered = rows.map(row => row.map(cell => renderInlineMarkdown(cell, options)));
+  const colWidths = Array.from({ length: width }, (_, col) => (
+    Math.max(...rendered.map(row => plain(row[col] || '').length))
+  ));
+  const sep = paint('│', [ANSI.muted], options);
+  return rendered.map((row, rowIndex) => {
+    const cells = Array.from({ length: width }, (_, col) => {
+      const cell = row[col] || '';
+      const pad = ' '.repeat(Math.max(0, colWidths[col] - plain(cell).length));
+      const value = `${cell}${pad}`;
+      return rowIndex === 0 ? paint(plain(value), [ANSI.bold], options) : value;
+    });
+    return `  ${cells.join(` ${sep} `)}`;
+  }).join('\n') + '\n';
+}
+
+function flushMarkdownTable(state, options = {}) {
+  if (!state.markdownTable.length) return '';
+  const table = renderMarkdownTable(state.markdownTable, options);
+  state.markdownTable = [];
+  return table;
+}
+
+function renderMarkdownLine(state, line, options = {}) {
+  const fenceMatch = /^\s*```/.test(line);
+  if (fenceMatch) {
+    state.markdownFence = !state.markdownFence;
+    const label = line.trim().slice(3).trim();
+    if (state.markdownFence && label) return `${paint(label, [ANSI.muted], options)}\n`;
+    return '';
+  }
+  if (state.markdownFence) {
+    return `  ${paint(line, [ANSI.accent], options)}\n`;
+  }
+  if (/^\s*\|/.test(line)) {
+    state.markdownTable.push(line);
+    return '';
+  }
+  let out = flushMarkdownTable(state, options);
+  const header = line.match(/^(#{1,6})\s+(.*)$/);
+  if (header) {
+    const codes = header[1].length <= 2 ? [ANSI.bold, ANSI.accent] : [ANSI.bold];
+    return `${out}${paint(renderInlineMarkdown(header[2], options).replace(/\x1b\[[0-9;]*m/g, ''), codes, options)}\n`;
+  }
+  if (/^\s*(?:-{3,}|_{3,}|\*{3,})\s*$/.test(line)) {
+    return `${out}${paint('─'.repeat(36), [ANSI.muted], options)}\n`;
+  }
+  const bullet = line.match(/^(\s*)[-*]\s+(.*)$/);
+  if (bullet) {
+    return `${out}${bullet[1]}${paint('•', [ANSI.bold], options)} ${renderInlineMarkdown(bullet[2], options)}\n`;
+  }
+  const quote = line.match(/^\s*>\s?(.*)$/);
+  if (quote) {
+    return `${out}${paint('│', [ANSI.muted], options)} ${paint(renderInlineMarkdown(quote[1], options).replace(/\x1b\[[0-9;]*m/g, ''), [ANSI.muted], options)}\n`;
+  }
+  return `${out}${renderInlineMarkdown(line, options)}\n`;
+}
+
+// Hybrid streaming renderer. Prose streams character-live through the inline
+// state machine (bold/code style as delimiters close), so chat feels
+// immediate. Structure-shaped lines (tables, fences, headers, bullets,
+// quotes) buffer to the line boundary and render as blocks, because they
+// cannot be styled until the whole line exists. The first character of each
+// line decides which lane the line takes.
+const MARKDOWN_BLOCK_LINE_START = new Set(['|', '#', '`', '>', '-', '*']);
+
 function renderStreamingMarkdown(state, text, options = {}) {
   ensureMarkdownState(state);
-  const input = `${state.markdownCarry || ''}${String(text || '')}`;
-  state.markdownCarry = '';
+  const input = String(text || '');
   let out = '';
 
   for (let i = 0; i < input.length;) {
     const char = input[i];
-    const next = input[i + 1];
 
+    // Structure lane: buffer the whole line, render at the newline.
+    if (state.markdownFence || state.markdownLineMode === 'block') {
+      if (char === '\n') {
+        out += renderMarkdownLine(state, state.markdownLine, options);
+        state.markdownLine = '';
+        state.markdownLineMode = 'start';
+      } else {
+        state.markdownLine += char;
+      }
+      i += 1;
+      continue;
+    }
+
+    // Line start: decide which lane this line takes.
+    if (state.markdownLineMode === 'start') {
+      if (char === '\n') {
+        out += flushMarkdownTable(state, options);
+        out += '\n';
+        i += 1;
+        continue;
+      }
+      if (MARKDOWN_BLOCK_LINE_START.has(char)) {
+        state.markdownLineMode = 'block';
+        state.markdownLine = char;
+        i += 1;
+        continue;
+      }
+      out += flushMarkdownTable(state, options);
+      state.markdownLineMode = 'prose';
+      continue;
+    }
+
+    // Prose lane: the inline state machine, character-live.
+    const next = input[i + 1];
     if (state.markdownMode === 'normal') {
+      if (state.markdownCarry === '*') {
+        state.markdownCarry = '';
+        if (char === '*') {
+          state.markdownMode = 'bold';
+          state.markdownBuffer = '';
+          i += 1;
+          continue;
+        }
+        out += '*';
+      }
+      if (char === '\n') {
+        out += '\n';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '*' && next === undefined) {
         state.markdownCarry = '*';
-        break;
+        i += 1;
+        continue;
       }
       if (char === '*' && next === '*') {
         state.markdownMode = 'bold';
@@ -924,23 +1139,52 @@ function renderStreamingMarkdown(state, text, options = {}) {
     }
 
     if (state.markdownMode === 'bold') {
+      if (char === '\n') {
+        out += `**${state.markdownBuffer}\n`;
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '*' && next === undefined) {
         state.markdownCarry = '*';
-        break;
+        i += 1;
+        continue;
       }
-      if (char === '*' && next === '*') {
+      if (char === '*' && (next === '*' || state.markdownCarry === '*')) {
         out += paint(state.markdownBuffer, [ANSI.bold], options);
         state.markdownMode = 'normal';
         state.markdownBuffer = '';
-        i += 2;
+        state.markdownCarry = '';
+        i += next === '*' ? 2 : 1;
         continue;
       }
+      if (state.markdownCarry === '*') {
+        state.markdownCarry = '';
+        if (char === '*') {
+          out += paint(state.markdownBuffer, [ANSI.bold], options);
+          state.markdownMode = 'normal';
+          state.markdownBuffer = '';
+          i += 1;
+          continue;
+        }
+        state.markdownBuffer += '*';
+      }
       state.markdownBuffer += char;
       i += 1;
       continue;
     }
 
     if (state.markdownMode === 'code') {
+      if (char === '\n') {
+        out += `\`${state.markdownBuffer}\n`;
+        state.markdownMode = 'normal';
+        state.markdownBuffer = '';
+        state.markdownLineMode = 'start';
+        i += 1;
+        continue;
+      }
       if (char === '`') {
         out += paint(state.markdownBuffer, [ANSI.accent], options);
         state.markdownMode = 'normal';
@@ -959,12 +1203,27 @@ function renderStreamingMarkdown(state, text, options = {}) {
 
 function flushStreamingMarkdown(state, output) {
   ensureMarkdownState(state);
-  let out = state.markdownCarry || '';
+  let out = '';
+  if (state.markdownLine) {
+    if (/^\s*```/.test(state.markdownLine)) {
+      // A fence marker with no trailing newline is a block boundary, not code.
+      state.markdownFence = !state.markdownFence;
+    } else if (state.markdownFence) {
+      out += `  ${paint(state.markdownLine, [ANSI.accent], output)}`;
+    } else {
+      out += renderMarkdownLine(state, state.markdownLine, output).replace(/\n$/, '');
+    }
+    state.markdownLine = '';
+  }
+  if (state.markdownCarry) {
+    out += state.markdownCarry;
+  }
   if (state.markdownMode === 'bold' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.bold], output);
   } else if (state.markdownMode === 'code' && state.markdownBuffer) {
     out += paint(state.markdownBuffer, [ANSI.accent], output);
   }
+  out += flushMarkdownTable(state, output);
   resetMarkdownState(state);
   if (out) output.write(out);
   return out;
@@ -1422,6 +1681,99 @@ function removeStoredApproval(ref, options = {}) {
   return record;
 }
 
+// Local turns stage side effects as signed artifacts in the workspace's
+// atris/approvals/ (atris.local_approval.v1), a different store from
+// ~/.atris/ax-approvals.json. ax --approve redeems them through the local
+// backend's approvals/execute endpoint, which re-signs with explicit user
+// approval and runs the gated executor.
+function workspaceApprovalsDir(cwd) {
+  return path.join(cwd || process.cwd(), 'atris', 'approvals');
+}
+
+function listWorkspaceApprovals(cwd) {
+  const dir = workspaceApprovalsDir(cwd);
+  let names = [];
+  try {
+    names = fs.readdirSync(dir).filter(name => name.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of names) {
+    const filePath = path.join(dir, name);
+    try {
+      const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (record && record.schema === 'atris.local_approval.v1') {
+        records.push({ path: filePath, record, mtimeMs: fs.statSync(filePath).mtimeMs });
+      }
+    } catch {
+      // Unreadable artifact: skip, never block the turn.
+    }
+  }
+  return records;
+}
+
+function findWorkspaceApproval(ref, cwd) {
+  const target = String(ref || '').trim();
+  if (!target) return null;
+  const matches = listWorkspaceApprovals(cwd)
+    .filter(item => String(item.record.approval_id || '').startsWith(target));
+  if (matches.length !== 1) return null;
+  return matches[0];
+}
+
+function pendingWorkspaceApprovalsSince(cwd, sinceMs) {
+  return listWorkspaceApprovals(cwd).filter(item => (
+    item.mtimeMs >= sinceMs
+    && String(item.record.status || '') === 'pending'
+    && !(item.record.decision && item.record.decision.approved)
+  ));
+}
+
+async function approveWorkspaceApproval(ref, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const found = findWorkspaceApproval(ref, cwd);
+  if (!found) throw new Error(`Pending approval not found: ${ref}`);
+  const output = options.output || process.stdout;
+  const { record } = found;
+  const startedAt = Date.now();
+  const payload = record.payload && typeof record.payload === 'object' ? record.payload : {};
+  output.write(`${formatAuxRow('id', record.approval_id, output)}\n`);
+  if (record.summary) output.write(`${formatAuxRow('action', record.summary, output)}\n`);
+  if (payload.command) output.write(`${formatAuxRow('command', payload.command, output)}\n`);
+  output.write('Accepted.\n');
+  const response = await postJson(APPROVAL_EXECUTE_PATH, {
+    model: modelForMode(options.mode || 'fast'),
+    approval_request: {
+      action_type: record.action_type,
+      approval_id: record.approval_id,
+      summary: record.summary,
+      payload: { ...payload, workspace: payload.workspace || cwd },
+    },
+  }, { route: 'local' });
+  const execution = response && response.data && typeof response.data === 'object' ? response.data : {};
+  const executed = Boolean(execution.execution && execution.execution.executed) || execution.status === 'executed';
+  const statusText = executed
+    ? 'Done.'
+    : `Not executed: ${String(execution.status || response.error || `HTTP ${response.status || 0}`)}`;
+  output.write(`${formatAuxRow(executed ? 'done' : 'wait', statusText, output)}\n`);
+  try {
+    const spent = { ...record, status: executed ? 'executed' : record.status, executed_at: executed ? new Date().toISOString() : undefined };
+    fs.writeFileSync(found.path, `${JSON.stringify(spent, null, 2)}\n`);
+  } catch {
+    // Bookkeeping only; the backend holds replay protection.
+  }
+  output.write(`${formatDoneLine(Date.now() - startedAt)}\n`);
+  if (!response.ok && !executed) process.exitCode = 1;
+  return { response, executed };
+}
+
+function writeWorkspaceApprovalHints(cwd, sinceMs, output) {
+  for (const item of pendingWorkspaceApprovalsSince(cwd, sinceMs)) {
+    output.write(`${formatAuxRow('approve', formatApprovalCommand(item.record.approval_id), output)}\n`);
+  }
+}
+
 function formatStoredApprovals(store, options = {}) {
   const approvals = Array.isArray(store && store.approvals) ? store.approvals : [];
   if (!approvals.length) return 'No pending approvals.';
@@ -1708,8 +2060,30 @@ function writeAuxLine(state, output, line) {
   state.needsBullet = true;
 }
 
+// Turns beyond the recent window used to fall off a cliff: turn 9 of a chat
+// silently forgot turn 1 and never said so. Evicted turns now compress into
+// a digest that rides as the first previous message, so long chats keep the
+// thread of the whole conversation. AX_NO_COMPACT=1 restores the bare window.
+const HISTORY_DIGEST_MAX_CHARS = 2400;
+
+function compactedHistoryDigest(evicted) {
+  const lines = [];
+  for (const turn of evicted) {
+    const who = turn && turn.role === 'assistant' ? 'atris' : 'user';
+    const text = String((turn && turn.content) || '').replace(/\s+/g, ' ').trim().slice(0, 160);
+    if (text) lines.push(`${who}: ${text}`);
+  }
+  let digest = lines.join('\n');
+  if (digest.length > HISTORY_DIGEST_MAX_CHARS) {
+    digest = digest.slice(digest.length - HISTORY_DIGEST_MAX_CHARS);
+    digest = digest.slice(digest.indexOf('\n') + 1);
+  }
+  return digest;
+}
+
 function structuredHistory(history, limit = 8) {
-  return (Array.isArray(history) ? history : [])
+  const rows = Array.isArray(history) ? history : [];
+  const recent = rows
     .slice(-limit)
     .map(turn => {
       const message = {
@@ -1722,6 +2096,16 @@ function structuredHistory(history, limit = 8) {
       return message;
     })
     .filter(turn => turn.content.trim());
+  if (rows.length <= limit || process.env.AX_NO_COMPACT === '1') return recent;
+  const digest = compactedHistoryDigest(rows.slice(0, rows.length - limit));
+  if (!digest) return recent;
+  return [
+    {
+      role: 'user',
+      content: `[conversation so far, compacted from ${rows.length - limit} earlier turns]\n${digest}`,
+    },
+    ...recent,
+  ];
 }
 
 function latestPendingTaskPreview(history = []) {
@@ -1871,6 +2255,19 @@ function codeFastWorkspaceNotice(result) {
 function handleEvent(event, state, output) {
   if (!event || typeof event !== 'object') return;
   state.events.push(event);
+  // AX_TIMING=1: phase scoreboard to stderr: one line per SSE event with ms
+  // since turn start and since the previous event, so latency work can see
+  // WHERE a slow turn spends its time (model TTFT vs tool exec vs loop count).
+  if (process.env.AX_TIMING === '1') {
+    const now = Date.now();
+    if (!state._t0) state._t0 = now;
+    const kind = event.type || event.status || 'event';
+    const detail = event.type === 'assistant_blocks' && Array.isArray(event.blocks)
+      ? event.blocks.map((b) => (b && b.type === 'tool_use' ? `tool:${b.tool}` : b && b.type)).join(',')
+      : event.type === 'tool_results' ? `results:${(event.results || []).length}` : '';
+    process.stderr.write(`[ax-timing] +${String(now - state._t0).padStart(6)}ms (gap ${String(now - (state._tPrev || now)).padStart(5)}ms) ${kind}${detail ? ' ' + detail : ''}\n`);
+    state._tPrev = now;
+  }
 
   if (event.type === 'system_init') {
     state.runtime = event;
@@ -1968,7 +2365,11 @@ function handleEvent(event, state, output) {
 }
 
 async function postTurn(message, options = {}) {
-  const route = options.business ? 'local' : resolveRoute(message, options);
+  let route = options.business ? 'local' : resolveRoute(message, options);
+  if (route === 'local' && !options.business && options.route !== 'local' && !options.forceLocal
+    && !(await localBackendReachable())) {
+    route = 'cloud';
+  }
   const local = route !== 'cloud';
   const endpointRoute = options.business ? 'cloud' : route;
   const token = authToken();
@@ -1987,7 +2388,11 @@ async function postTurn(message, options = {}) {
   // Relayed business turns wait on EC2 terminal calls (up to 60s each) with no
   // SSE traffic in between, so the socket-idle timeout needs more headroom.
   const baseTimeoutMs = payload.model === 'atris:max' ? 300000 : payload.model === 'atris:pro' ? 180000 : 60000;
-  const timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
+  let timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
+  // Local workspace tool loops (max_turns 8/14) legitimately run past the fast
+  // lane's 60s chat wall — SwapBench 2026-07-02: three tool-loop tasks died at
+  // ~60s as "Atris cloud did not respond". Same headroom as business relays.
+  if (local) timeoutMs = Math.max(timeoutMs, 180000);
   const turnUrl = new URL(backendUrl({ route: endpointRoute }));
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
@@ -2225,6 +2630,7 @@ async function chat(options = {}) {
   const logger = createRunLogger({ cwd, mode, kind: 'play', output: baseOutput });
   const output = logger ? logger.output : baseOutput;
   const history = [];
+  let lastCompactionNotice = 0;
   const conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
 
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
@@ -2357,10 +2763,24 @@ async function chat(options = {}) {
     const pendingTaskPreview = latestPendingTaskPreview(history);
     const route = pendingTaskPreview ? 'cloud' : options.route;
     maybeWriteAtrisGoalBanner(output, cwd);
-    const turnRoute = options.business ? 'cloud' : resolveRoute(trimmed, { route });
+    let turnRoute = options.business ? 'cloud' : resolveRoute(trimmed, { route, cwd });
+    // Same downgrade as postTurn: an auto-routed local turn with no local
+    // backend listening becomes a cloud turn instead of a blocked preflight
+    // that dumps localhost start instructions at a consumer. Explicit --local
+    // keeps the real error.
+    if (turnRoute === 'local' && route !== 'local' && !options.forceLocal) {
+      const probeLocal = options.localBackendProbe || localBackendReachable;
+      if (!(await probeLocal())) turnRoute = 'cloud';
+    }
     if (!(await ensureRuntimeReady(turnRoute))) return false;
     const turnFunction = options.turnFunction || turnFunctionForMode(mode);
     const turnId = options.turnId || createTurnId();
+    const turnStartedAt = Date.now();
+    const compactedTurns = process.env.AX_NO_COMPACT === '1' ? 0 : Math.max(0, history.length - 8);
+    if (compactedTurns > 0 && compactedTurns !== lastCompactionNotice) {
+      lastCompactionNotice = compactedTurns;
+      output.write(`${paint(`· context: ${compactedTurns} earlier turn${compactedTurns === 1 ? '' : 's'} compacted into a digest`, [ANSI.muted], output)}\n`);
+    }
     const result = await turnFunction(trimmed, { mode, cwd, history, output, route, business: options.business, verify: options.verify, conversationId, turnId });
     if (result.output && !result.output.endsWith('\n')) output.write('\n');
     const approvalExecution = normalizeMode(mode) === 'code-fast'
@@ -2370,7 +2790,11 @@ async function chat(options = {}) {
         output,
         ...(options.postApproval ? { postApproval: options.postApproval } : {}),
       });
-    output.write(`${formatDoneLine(result.durationMs, creditsFromState(result))}\n\n`);
+    if (!options.turnFunction) 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`);
+    output.write('\n');
     const receipt = receiptFromState(result);
     const approvalRequest = approvalExecution
       ? (
@@ -3282,7 +3706,11 @@ async function main() {
     }
 
     if (approveId) {
-      await approveStoredApproval(approveId, { mode, output: process.stdout });
+      if (findStoredApproval(approveId)) {
+        await approveStoredApproval(approveId, { mode, output: process.stdout });
+      } else {
+        await approveWorkspaceApproval(approveId, { cwd: process.cwd(), mode, output: process.stdout });
+      }
       return;
     }
 
@@ -3300,6 +3728,7 @@ async function main() {
     console.log(formatHeader({ mode, cwd: process.cwd(), chat: false }, process.stdout));
     console.log('');
     maybeWriteAtrisGoalBanner(process.stdout, process.cwd());
+    const turnStartedAt = Date.now();
     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);
@@ -3307,11 +3736,21 @@ async function main() {
       ? persistPendingApproval(receipt, approvalRequest, { cwd: process.cwd(), mode })
       : null;
     if (approvalRecord) console.log(formatAuxRow('approve', formatApprovalCommand(approvalRecord.id), process.stdout));
+    // A one-shot has no next turn, so "reply yes to approve" is a dead end;
+    // surface the exact redeem command for anything the turn staged on disk.
+    writeWorkspaceApprovalHints(process.cwd(), turnStartedAt, process.stdout);
     console.log('');
     console.log(formatDoneLine(result.durationMs, creditsFromState(result)));
   } catch (error) {
     console.error(`x ${error.message}`);
-    printBackendHint({ route: route === 'auto' ? undefined : route });
+    // Only name a lane when the user picked one. An auto-routed turn that
+    // failed locally must not claim "Atris cloud did not respond" (seen live
+    // 2026-07-02 after a local workspace-root rejection).
+    if (route === 'auto') {
+      console.error('\nRetry, or run ax --doctor to check the runtime.');
+    } else {
+      printBackendHint({ route });
+    }
     process.exit(1);
   }
 }
@@ -3327,6 +3766,10 @@ module.exports = {
   approvalRequestFromReceipt,
   approvalStorePath,
   approveStoredApproval,
+  approveWorkspaceApproval,
+  findWorkspaceApproval,
+  listWorkspaceApprovals,
+  pendingWorkspaceApprovalsSince,
   backendBaseUrl,
   backendStartCommand,
   backendUrl,