atris 3.35.0 → 3.36.0

package/atris/skills/improve/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: improve
-description: "Run one RL improvement tick on the workspace via POST /api/improve. Ships one verifiable change, scores it, writes the scorecard. The thing you pay for. Triggers on: improve, make this better, ship one thing, run a tick, get smarter."
-version: 1.0.0
+description: "Run one verified, scored improvement tick and write its receipt. Use when the user asks to improve, make this better, ship one thing, run a tick, or get smarter. `atris improve` alone shows metabolism vitals; use `atris improve tick` to ship work."
+version: 1.1.0
 tags:
   - rl
   - improve
@@ -12,74 +12,94 @@ tags:
 
 # /improve
 
-Runs one improvement tick on the workspace. Calls `POST /api/improve` on the backend, which plans one task, builds it, verifies it, and scores it. Returns what shipped + the reward. Writes the scorecard locally.
+Run one improvement tick on the workspace. A successful tick ships one result, passes a real verifier, receives a score, and writes a machine-readable scorecard.
 
-This is the product. The thing the user pays for. One call, one verifiable result.
+One call means one verifiable result. Never turn one invocation into a hidden batch.
 
-## How it works
+## Command contract
 
+`atris improve` alone shows the self-improvement metabolism vitals. It does not ship a change.
+
+Use the explicit `tick` subcommand when the user asks for improvement work:
+
+```bash
+atris improve tick                    # one full tick: plan, build, verify, score
+atris improve tick --json             # the same tick as machine-readable output
+atris improve tick plan               # plan only; no change or receipt
+atris improve tick --dry-run          # execute without committing; no shipping receipt
+atris improve tick --no-fallback      # report API failure instead of running locally
+atris improve history                 # reward trend, credits, and pass rate
+atris improve                         # vitals only
+atris improve --json                  # vitals only as JSON
 ```
-/improve
-  → POST /api/improve { workspace: ".", mode: "full" }
-  → backend picks a task, plans, builds, reviews, verifies
-  → returns { task, reward, files_changed, verify_pass, summary }
-  → CLI writes scorecard to .atris/presidio/scorecards.md
-  → CLI reports result to user
-```
 
-The inference is Claude Code (or whatever model the backend uses). The environment is the folder. The endpoint is the bridge.
+## Run one tick
+
+1. Run `atris improve tick`, adding `--json` only when structured output is useful.
+2. Inspect the returned source, task summary, verifier result, reward, files, and receipt path.
+3. Count the tick only when `ok` is true, verification passed, and the scorecard was written.
+4. Report what shipped and the exact verifier result. If the tick fails, report the failure and stop.
+
+For a paid API tick, the CLI:
 
-## On invoke
+1. Loads credentials with `utils/auth.loadCredentials`.
+2. Calls `POST /api/improve` with the workspace, mode, model, and dry-run setting.
+3. Lets the backend plan, build, verify, score, and bill the successful tick.
+4. Writes the normalized receipt to `.atris/state/scorecards.jsonl` and the human trail to the daily Atris journal.
 
-Run the CLI command — it does the whole tick (auth, the credit-metered call, scorecard, fallback):
+The full response may omit the billed credit count. In that case the CLI reports that billing happened server-side instead of inventing a number.
+
+## Local fallback
+
+Local fallback is allowed when there is no login, the backend is unreachable, or the hosted backend cannot access the local workspace path. The CLI runs this exact bounded command internally:
 
 ```bash
-atris improve            # one full tick: plan → build → verify → score (deducts credits)
-atris improve plan       # show the plan only, change nothing
-atris improve --json     # machine-readable result (this is what the member loop consumes)
-atris improve --no-fallback   # fail loudly instead of running a local tick when the backend is down
+atris mission run --due --headless --max-ticks 1 --complete-on-pass --json
 ```
 
-Under the hood `atris improve` (`commands/improve.js`):
+The local result succeeds only when all of these are true:
 
-1. Loads the auth token via `utils/auth.loadCredentials`
-2. `POST /api/improve { workspace, mode, model }` via `utils/api.apiRequestJson`
-3. The backend plans, builds, runs the verify command, scores it, and **deducts Atris credits per successful tick** (`bill_tick`)
-4. Writes a per-tick scorecard row to `.atris/state/scorecards.jsonl` (the receipt the brain ledger counts)
-5. Falls back to a local autopilot tick **only** when you are not logged in or the backend is unreachable — a real error (insufficient credits, server error) is reported, never silently retried
+1. Exactly one mission tick ran.
+2. A headless worker actually ran; caller-session and no-worker placeholders are rejected.
+3. The mission verifier passed.
+4. The scorecard and journal receipt were written.
 
-The full-mode response does not echo `credits_deducted` (credits are still billed server-side), so the CLI shows "billed server-side" when the count is absent. To call the endpoint directly instead of the command, `POST /api/improve` with `{ workspace, mode, model }`.
+A verified local tick earns the conservative local reward of `+1` and deducts no credits. No due headless mission, a skipped worker, a failed or missing verifier, or a receipt write failure makes the improve command fail without a reward.
 
-## Modes
+Do not silently fall back for answerable API failures such as insufficient credits, unrelated authorization failures, or server errors.
 
-- `full` — plan, build, review, verify (default)
-- `plan` — just pick the task and show what it would do
-- `dry_run` — run everything but don't commit
+## Expected output
 
-## Fallback
+User says: "Improve this once."
 
-If the backend is unreachable (no auth, no network, localhost not running), fall back to local mode: run `atris autopilot --auto --iterations=1` instead. Same loop, just local inference via `claude -p` subprocess. Report that it ran locally.
+Action: run `atris improve tick`.
 
-## Output
+Expected shape:
 
-```
+```text
 improved.
+  task:    fixed the stale wiki reference
+  verify:  pass
+  reward:  4
+  files:   atris/wiki/auth-flow.md
+  scorecard: .atris/state/scorecards.jsonl
+```
 
-  task:    fixed the stale wiki ref in auth-flow.md
-  verify:  pass (npm test, 143/143)
-  reward:  +4
-  files:   atris/wiki/briefs/auth-flow.md
-  time:    47s
+For local fallback, the first line is `improved (local fallback).` and the report still names the task, passing verifier, reward, and scorecard.
 
-  scorecard updated.
-```
+## Failure handling
+
+- If verification fails or is missing, halt honestly and write a durable lesson. Do not claim improvement.
+- If the command reports no due headless mission, stop; do not manufacture busywork or a scorecard.
+- If the API returns insufficient credits or another answerable error, report it without a local retry.
+- If the workspace is dirty, preserve existing changes. Use an isolated worktree for manual follow-up fixes.
+- If a worker lands work but the outer receipt fails, report the landed commit separately and do not count the improve tick.
 
 ## Rules
 
 - One tick only. Never batch.
-- Always verify. No reward without a check.
+- No reward without a passing verifier.
 - Show what shipped, not what was attempted.
-- Write the scorecard. This is the receipt.
-- If verify fails, halt honestly and write a lesson.
-- Fallback to local if backend is unreachable. Never error silently.
+- A scorecard is required for success.
+- Preserve user work and unrelated changes.
 - The user pays because something real happened. Never fake it.

package/atris/skills/youtube/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: youtube
 description: "Process YouTube videos — extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
-version: 2.2.0
+version: 2.3.0
 tags:
   - youtube
   - research
@@ -13,6 +13,15 @@ tags:
 
 Process any YouTube video through Atris transcript-first analysis. The CLI extracts local captions with timestamps when available, sends that transcript to Atris, and falls back to cloud video processing when captions are unavailable or unusable. 5 credits per video, refunded if processing fails.
 
+## Route first: learning vs product
+
+Two rails process YouTube videos — pick before running anything:
+
+- **Learning / work rail** → use the `alpha-learn` skill (ytnotes). Local yt-dlp + grok, zero credits, podcastnotes-style notes, tweet-feed output, `[claimable]` entries in today's journal for other agents. Use this when the goal is to LEARN from a video or mine it for Atris work.
+- **Product rail** → this skill (`atris youtube process`). Credits-billed, stores knowledge in the Atris backend, customer-facing path. Use this when a customer/agent needs the video stored as Atris knowledge or answered via the API.
+
+If the user says "learn from", "notes on", "alpha", or "rabbit hole" → alpha-learn. If they say "process", "store", "add to knowledge" → this skill.
+
 ## Bootstrap (ALWAYS Run First)
 
 ```bash

package/atris.md

@@ -90,6 +90,8 @@ The same discipline for words. Output stays sharp no matter how bloated the cont
   - "Missions survive everything: one engine starts the work, another picks it up cold, a third lands it. Work is no longer tied to a chat window, a session, or a vendor."
   - "The system reports in plain English: one daily message with what landed, what waits on you, and who should own what's next. One person can supervise many projects."
 - **Fit the screen.** An operator-facing report shows three results, air between them, and holds the rest on ask. No scrolling: reading it is one glance, and the reader asks for more if they want more.
+- **Human surfaces are gated.** Anything rendered for the operator (brief, digest, boot) goes through the operator-voice translator and a deterministic jargon gate; raw ids, commands, paths, and test tallies never reach a page. A gate violation is a build error, not a style note.
+- **Interview the fuzz.** When the operator hands off a fuzzy build ("make me the best X", "yeah ok this is my thought, go make it"), do not ask open questions and do not dispatch as-is. Offer 2-3 named interpretations with a recommendation ("best could mean capture, resurfacing, or closure: I'd bet resurfacing, right?") so the operator confirms or corrects in five words. Repeat until the brief fits one screen (goal, why now, done-looks-like, open risks), show the brief, then dispatch. The interview lends the operator a structure to think in; the sharpened brief is what makes every downstream lap cheap.
 
 `expected`: this is how an Atris agent writes and builds. Shipping slop or rambling is a failure smell, same as drift or a stale task.
 

package/ax

@@ -12,6 +12,7 @@ const permissionGrants = require(path.join(__dirname, 'lib', 'permission-grants.
 const { loadCredentials } = require('./utils/auth');
 const { apiRequestJson, getApiBaseUrl } = require('./utils/api');
 const missionRuntime = require('./lib/mission-runtime-loop');
+const { pickLane } = require('./lib/ax-auto-lane');
 
 const EXIT_WORDS = new Set(['exit', 'quit', ':q']);
 const BACKEND = {
@@ -34,6 +35,9 @@ const APPROVAL_EXECUTE_PATH = '/api/atris2/approvals/execute';
 const BACKEND_API_TOOL_NAME = 'backend_api';
 const BACKEND_API_TOOL_RESULT_PATH = '/api/atris2/turn/tool-result';
 const DEFAULT_APPROVAL_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TURN_TIMEOUT_MS = 60000;
+const PRO_TURN_TIMEOUT_MS = 180000;
+const MAX_TURN_TIMEOUT_MS = 300000;
 const CONNECTOR_NAMES = {
   gmail: 'Gmail',
   google_calendar: 'Google Calendar',
@@ -97,6 +101,33 @@ function modelForMode(mode) {
   return mode === 'fast' ? 'atris:fast' : 'atris:pro';
 }
 
+function payloadCanRunTools(payload = {}, options = {}) {
+  return Boolean(
+    options.business
+    || options.local
+    || payload.local_executor
+    || (Array.isArray(payload.local_tools) && payload.local_tools.length > 0)
+  );
+}
+
+function postTurnTimeoutMs(payload = {}, options = {}) {
+  const model = String(payload.model || '');
+  let timeoutMs = DEFAULT_TURN_TIMEOUT_MS;
+  if (model === 'atris:max') timeoutMs = MAX_TURN_TIMEOUT_MS;
+  else if (model === 'atris:pro') timeoutMs = PRO_TURN_TIMEOUT_MS;
+
+  // 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)) {
+    timeoutMs = Math.max(timeoutMs, PRO_TURN_TIMEOUT_MS);
+  }
+  if (options.business || options.local) {
+    timeoutMs = Math.max(timeoutMs, PRO_TURN_TIMEOUT_MS);
+  }
+  return timeoutMs;
+}
+
 function formatDuration(ms) {
   const value = Number(ms) || 0;
   if (value < 1000) return `${Math.max(0, Math.round(value))}ms`;
@@ -131,9 +162,9 @@ function formatUsage() {
     'ax - Atris local/code agent',
     '',
     'Usage:',
-    '  ax [--max|--pro|--fast|--code-fast] [--local|--cloud] <message>',
-    '  ax [--max|--pro|--fast|--code-fast] [--local|--cloud] --print <message>',
-    '  ax [--max|--pro|--fast|--code-fast] [--local|--cloud] --chat',
+    '  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 --approvals',
@@ -147,13 +178,14 @@ function formatUsage() {
     '  ax [--max|--fast] --benchmark',
     '',
     'Modes:',
+    '  --auto  pick a lane for each message and say why',
     '  --max   hosted Atris 2, highest reasoning, slowest turns',
     '  --pro   hosted Atris 2, deeper tool loop',
     '  --fast  hosted Atris 2, faster low-latency turns',
     '  --code-fast  Atris Code Fast public lane',
     '  --local opt into local backend/workspace tools',
     '  --cloud force authenticated cloud connectors/chat',
-    '  --print  headless JSON result: { ok, model, output, durationMs }',
+    '  --print  headless JSON result, including auto_lane and auto_reason with --auto',
     '  --business <slug>  run tools on that business cloud workspace (EC2)',
     '  --verify <cmd>  gate the turn on this command passing (default: no verifier)',
     '',
@@ -199,10 +231,29 @@ function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', out
   ].join('\n'));
 
   let redactedChars = 0;
+  let logBuffer = '';
+  let logFlushTimer = null;
+  const flushLogBuffer = () => {
+    if (logFlushTimer) {
+      clearTimeout(logFlushTimer);
+      logFlushTimer = null;
+    }
+    if (!logBuffer) return;
+    fs.appendFileSync(logPath, logBuffer);
+    logBuffer = '';
+  };
+  const scheduleLogFlush = () => {
+    if (logFlushTimer) return;
+    logFlushTimer = setTimeout(() => {
+      logFlushTimer = null;
+      flushLogBuffer();
+    }, 500);
+  };
   const writeLog = (chunk) => {
     const text = stripAnsi(chunk);
     if (fullTranscript) {
-      fs.appendFileSync(logPath, text);
+      logBuffer += text;
+      scheduleLogFlush();
       return;
     }
     redactedChars += text.length;
@@ -222,6 +273,7 @@ function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', out
     output: teeOutput,
     write: writeLog,
     close(exitCode = 0) {
+      flushLogBuffer();
       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');
@@ -229,6 +281,7 @@ function createRunLogger({ cwd = process.cwd(), mode = 'pro', kind = 'play', out
         return;
       }
       writeLog(`\nexit_code: ${exitCode}\nfinished_at: ${new Date().toISOString()}\n`);
+      flushLogBuffer();
     }
   };
 }
@@ -904,10 +957,38 @@ function normalizeMode(mode) {
   return mode === 'fast' ? 'fast' : 'pro';
 }
 
+function appendAutoPick(message, picked, options = {}) {
+  try {
+    const dir = path.join(os.homedir(), '.atris');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(path.join(dir, 'ax-auto-picks.jsonl'), `${JSON.stringify({
+      at: new Date().toISOString(),
+      lane: picked.lane,
+      reason: picked.reason,
+      message_chars: String(message || '').length,
+      print: Boolean(options.print),
+    })}\n`);
+  } catch (_) {
+    // Lane telemetry is best-effort and must never block a turn.
+  }
+}
+
+function autoLaneForMessage(message, options = {}) {
+  const picked = pickLane(message);
+  appendAutoPick(message, picked, options);
+  const errorOutput = options.errorOutput || process.stderr;
+  errorOutput.write(`${picked.reason}\n`);
+  return picked;
+}
+
 function formatPrompt(mode, options = {}) {
   if (!mode) return '› ';
   const tier = normalizeMode(mode);
-  return `${paint(tier, [ANSI.bold, tierColor(tier)], options)} › `;
+  const label = paint(tier, [ANSI.bold, tierColor(tier)], options);
+  if (options.approveMode === 'auto') {
+    return `${label} ${paint('[auto-approve]', [ANSI.muted], options)} › `;
+  }
+  return `${label} › `;
 }
 
 const TIER_COMMANDS = new Map([
@@ -924,6 +1005,8 @@ 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'],
 ];
@@ -2670,14 +2753,7 @@ async function postTurn(message, options = {}) {
   const payload = buildPayload(message, { ...options, route, connectionContext, connectionUserId, turnId });
   const postData = JSON.stringify(payload);
   const output = options.output || process.stdout;
-  // Relayed business turns wait on EC2 terminal calls (up to 60s each) with no
-  // SSE traffic in between, so the socket-idle timeout needs more headroom.
-  const baseTimeoutMs = payload.model === 'atris:max' ? 300000 : payload.model === 'atris:pro' ? 180000 : 60000;
-  let timeoutMs = options.business ? Math.max(baseTimeoutMs, 180000) : baseTimeoutMs;
-  // Local workspace tool loops (max_turns 16/24) 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 timeoutMs = postTurnTimeoutMs(payload, { business: options.business, local });
   const turnUrl = new URL(backendUrl({ route: endpointRoute }));
   const transport = turnUrl.protocol === 'https:' ? https : http;
   const state = {
@@ -2940,6 +3016,9 @@ async function runHeadlessTurn(message, options = {}) {
   const startedAt = Date.now();
   const sink = options.output || bufferedOutput();
   const turnFunction = options.turnFunction || turnFunctionForMode(mode);
+  const autoFields = options.autoLane && options.autoReason
+    ? { auto_lane: normalizeMode(options.autoLane), auto_reason: String(options.autoReason) }
+    : {};
 
   try {
     const result = await turnFunction(message, {
@@ -2956,6 +3035,7 @@ async function runHeadlessTurn(message, options = {}) {
       model: modelForMode(mode),
       output: String((result && result.output) || '').trim(),
       durationMs: Number((result && result.durationMs) || 0) || (Date.now() - startedAt),
+      ...autoFields,
     };
   } catch (error) {
     return {
@@ -2964,6 +3044,7 @@ async function runHeadlessTurn(message, options = {}) {
       output: '',
       durationMs: Date.now() - startedAt,
       error: String((error && error.message) || error || 'headless turn failed'),
+      ...autoFields,
     };
   }
 }
@@ -2977,7 +3058,9 @@ async function chat(options = {}) {
   const output = logger ? logger.output : baseOutput;
   const history = [];
   let lastCompactionNotice = 0;
-  const conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
+  let conversationId = options.conversationId || `ax-${process.pid}-${Date.now().toString(36)}`;
+  const session = { approveMode: 'stage' };
+  let turnInFlight = false;
 
   output.write(`${formatHeader({ mode, cwd, chat: true }, output)}\n\n`);
   if (logger) output.write(`${formatAuxRow('log', formatPathSubject(logger.path, output), output)}\n\n`);
@@ -3024,11 +3107,31 @@ async function chat(options = {}) {
       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`);
       return false;
     }
 
+    if (options.auto) {
+      mode = autoLaneForMessage(trimmed, {
+        errorOutput: options.errorOutput,
+        print: false,
+      }).lane;
+    }
+
     if (logger) logger.write(`${formatPrompt(mode)}${trimmed}\n`);
     output.write('\n');
 
@@ -3956,7 +4059,17 @@ async function main() {
     args.splice(verifyIdx, 2);
   }
 
-  const mode = args.includes('--code-fast') || args.includes('--code') ? 'code-fast' : args.includes('--max') ? 'max' : args.includes('--fast') ? 'fast' : 'pro';
+  const explicitLane = args.includes('--code-fast') || args.includes('--code')
+    ? 'code-fast'
+    : args.includes('--max')
+      ? 'max'
+      : args.includes('--fast')
+        ? 'fast'
+        : args.includes('--pro')
+          ? 'pro'
+          : null;
+  const autoEnabled = args.includes('--auto') && !explicitLane;
+  let mode = explicitLane || 'pro';
   const doctor = args.includes('--doctor');
   const selfTest = args.includes('--self-test');
   const benchmark = args.includes('--benchmark');
@@ -4017,7 +4130,7 @@ async function main() {
 
   const route = forceCloud ? 'cloud' : forceLocal ? 'local' : 'auto';
   const prompt = args
-    .filter(arg => !['--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--approvals', '--self-test', '--benchmark', '--print', '--headless', '--local', '--cloud', '--help', '-h'].includes(arg))
+    .filter(arg => !['--auto', '--max', '--fast', '--pro', '--code-fast', '--code', '--chat', '--doctor', '--approvals', '--self-test', '--benchmark', '--print', '--headless', '--local', '--cloud', '--help', '-h'].includes(arg))
     .join(' ')
     .trim();
 
@@ -4039,6 +4152,12 @@ async function main() {
     return;
   }
 
+  const startsChat = !printMode && (!prompt || args.includes('--chat'));
+  const autoPick = autoEnabled && prompt && !startsChat
+    ? autoLaneForMessage(prompt, { print: printMode })
+    : null;
+  if (autoPick) mode = autoPick.lane;
+
   let business = null;
   if (businessSlug) {
     if (normalizeMode(mode) === 'code-fast') {
@@ -4163,14 +4282,22 @@ async function main() {
 
     if (printMode) {
       const payload = prompt
-        ? await runHeadlessTurn(prompt, { mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify })
+        ? await runHeadlessTurn(prompt, {
+          mode,
+          cwd: process.cwd(),
+          route: route === 'auto' ? undefined : route,
+          business,
+          verify,
+          autoLane: autoPick && autoPick.lane,
+          autoReason: autoPick && autoPick.reason,
+        })
         : { ok: false, model: modelForMode(mode), output: '', durationMs: 0, error: 'missing prompt' };
       console.log(JSON.stringify(payload));
       process.exit(payload.ok ? 0 : 1);
     }
 
     if (!prompt || args.includes('--chat')) {
-      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify });
+      await chat({ mode, cwd: process.cwd(), route: route === 'auto' ? undefined : route, business, verify, auto: autoEnabled });
       return;
     }
 
@@ -4276,6 +4403,7 @@ module.exports = {
   postApprovalExecution,
   postCodeFastTurn,
   postTurn,
+  postTurnTimeoutMs,
   readApprovalStore,
   removeStoredApproval,
   renderStreamingMarkdown,