atris 3.52.0 → 3.55.0

package/commands/avail.js

@@ -10,6 +10,7 @@
 
 const { ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson, getAppBaseUrl, httpRequest } = require('../utils/api');
+const { argsWantHelp } = require('../lib/noninteractive');
 
 const DAY_INDEX = { mon: 0, tue: 1, wed: 2, thu: 3, fri: 4, sat: 5, sun: 6 };
 const DAY_LABEL = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
@@ -381,14 +382,14 @@ Examples:
 }
 
 async function availCommand(argv = []) {
+  if (argsWantHelp(argv)) {
+    printHelp();
+    return 2;
+  }
   if (!argv.length || argv[0]?.startsWith('-') || argv[0] === 'show' || argv[0] === 'get') {
     return showAvail({ json: argv.includes('--json') });
   }
   const sub = argv[0].toLowerCase();
-  if (sub === '--help' || sub === '-h' || sub === 'help') {
-    printHelp();
-    return 0;
-  }
   if (sub === 'set' || sub === 'update') return setAvail(argv.slice(1));
   if (sub === 'slots') return slotsAvail(argv.slice(1));
   console.error(`Unknown subcommand: ${sub}`);

package/commands/balance.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const {
+  NOT_LOGGED_IN,
+  wantsHelp,
+  wantsJson,
+  tokenFrom,
+  oneLine,
+  printResult,
+  formatDollars,
+  normalizeBalance,
+} = require('../lib/developer-api');
+
+function showBalanceHelp() {
+  console.log('usage: atris balance [--json]');
+  console.log('show your credit balance in dollars, with credits on the next line.');
+}
+
+async function balanceCommand(args = [], deps = {}) {
+  if (wantsHelp(args)) {
+    showBalanceHelp();
+    return 0;
+  }
+
+  const json = wantsJson(args);
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  const load = deps.loadCredentials || loadCredentials;
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = tokenFrom(load());
+  if (!token) {
+    printResult({ json, ok: false, error: NOT_LOGGED_IN, payload: { ok: false, error: NOT_LOGGED_IN } }, io);
+    return 1;
+  }
+
+  try {
+    const result = await request('/credits/balance', { method: 'GET', token });
+    if (!result || !result.ok) {
+      const error = oneLine(result && result.error);
+      printResult({ json, ok: false, error, payload: { ok: false, error, status: result && result.status } }, io);
+      return 1;
+    }
+    const balance = normalizeBalance(result.data || {});
+    const text = `${formatDollars(balance.dollars)}\n${balance.credits} credits`;
+    printResult({ json, ok: true, text, payload: { ok: true, ...balance } }, io);
+    return 0;
+  } catch (error) {
+    const message = oneLine(error && error.message);
+    printResult({ json, ok: false, error: message, payload: { ok: false, error: message } }, io);
+    return 1;
+  }
+}
+
+module.exports = { balanceCommand, showBalanceHelp };

package/commands/bench.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+
 const {
   BenchInfraError,
   packMetadata,
@@ -10,6 +13,18 @@ const {
 const { buildBenchReport, renderBenchReportText } = require('../lib/bench/report');
 const { hasFlag } = require('../lib/arg-parser');
 
+function isAtrisCliRepo(cwd = process.cwd()) {
+  const root = path.resolve(cwd);
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    if (pkg.name !== 'atris') return false;
+  } catch {
+    return false;
+  }
+  return fs.existsSync(path.join(root, 'bin', 'atris.js'))
+    && fs.existsSync(path.join(root, 'atris', 'benchmarks'));
+}
+
 // Preserve the existing rule that any inline value wins over a split value.
 function readInlineFirstFlag(args, name) {
   const prefix = `${name}=`;
@@ -41,6 +56,9 @@ function printHelp() {
   console.log('Usage: atris bench tasks [--pack <id>] [--json]');
   console.log('Usage: atris bench packs [--json]');
   console.log('Usage: atris bench report [--pack agents-v1] [--json]');
+  console.log('');
+  console.log('Bench runs product gates and only belongs in the atris CLI repo.');
+  console.log('Pass --here to allow running outside that repo.');
 }
 
 function printRunText(record) {
@@ -167,11 +185,20 @@ function reportCommand(args) {
 
 async function benchCommand(args = []) {
   const subcommand = args[0] || 'run';
-  const rest = args.slice(1);
+  const rest = args.slice(1).filter((arg) => arg !== '--here');
   if (subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
     printHelp();
     return 0;
   }
+  if (!hasFlag(args, '--here') && !isAtrisCliRepo(process.cwd())) {
+    const message = 'refuse outside the atris cli repo; pass --here to run here';
+    if (hasFlag(args, '--json') || hasFlag(rest, '--json')) {
+      console.log(JSON.stringify({ schema: 'atris.bench.error.v1', error: message }));
+    } else {
+      console.error(`atris bench: ${message}`);
+    }
+    return 2;
+  }
   if (subcommand === 'run') return runCommand(rest);
   if (subcommand === 'tasks') return tasksCommand(rest);
   if (subcommand === 'packs') return packsCommand(rest);
@@ -183,4 +210,5 @@ async function benchCommand(args = []) {
 
 module.exports = {
   benchCommand,
+  isAtrisCliRepo,
 };

package/commands/brain.js

@@ -5,6 +5,7 @@ const { spawnSync } = require('child_process');
 const { refreshNowFile } = require('./now');
 const escapeRegExp = require('../lib/escape-regexp');
 const { hasRenderedSections, isOpenSection, isDoneSection } = require('../lib/todo-sections');
+const { isNonInteractive } = require('../lib/noninteractive');
 const {
   renderVoiceCardBlock,
   upsertCursorVoiceCard,
@@ -70,6 +71,7 @@ function parseArgs(args) {
     root: process.cwd(),
     verify: false,
     json: false,
+    yes: false,
     rating: null,
     recommendation: null,
     note: '',
@@ -88,6 +90,8 @@ function parseArgs(args) {
       options.verify = true;
     } else if (arg === '--json') {
       options.json = true;
+    } else if (arg === '--yes' || arg === '-y') {
+      options.yes = true;
     } else if (arg === '--rating' && args[i + 1]) {
       options.rating = args[++i];
     } else if (arg.startsWith('--rating=')) {
@@ -1436,7 +1440,7 @@ function generatedBootBlock(state, voiceCard = voiceCardForRoot(state.root)) {
 This workspace has a compiled agent brain.
 
 On session start, activate it first:
-\`atris brain activate --root . --verify\`
+\`atris brain activate --root . --yes --verify\`
 
 Load these first:
 ${renderBulletedLoadOrder(state)}
@@ -1450,7 +1454,7 @@ Keep this voice beside every reply:
 ${renderVoiceCardBlock(voiceCard)}
 
 Re-run after meaningful work:
-\`atris brain compile --root .\`
+\`atris brain compile --root . --yes\`
 ${GENERATED_END}
 `;
 }
@@ -1471,6 +1475,40 @@ function upsertGeneratedBlock(filePath, title, block) {
   fs.writeFileSync(filePath, `${current.trimEnd()}\n\n${block}`, 'utf8');
 }
 
+function plannedBrainWrites(state) {
+  const files = [
+    'atris/brain/STATUS.md',
+    'atris/brain/self_improvement_ledger.md',
+    'atris/brain/state.json',
+    'AGENTS.md',
+    'CLAUDE.md',
+    'GEMINI.md',
+    '.cursor/rules/atris-voice.mdc',
+  ];
+  if (fs.existsSync(path.join(state.root, 'atris', 'wiki', 'STATUS.md'))) {
+    files.push('atris/wiki/STATUS.md');
+  }
+  return files;
+}
+
+function refuseBrainWriteWithoutYes(state, options = {}) {
+  const files = plannedBrainWrites(state);
+  if (options.json) {
+    console.log(JSON.stringify({
+      ok: true,
+      action: 'brain_plan',
+      files,
+      next_command: 'atris brain compile --yes',
+    }, null, 2));
+  } else {
+    console.log('Plan only. Would write:');
+    for (const file of files) console.log(`  ${file}`);
+    console.log('Re-run with --yes to write these files.');
+  }
+  if (isNonInteractive()) process.exit(2);
+  return { planned: true, files };
+}
+
 function writeBrain(state) {
   const brainDir = path.join(state.root, 'atris', 'brain');
   fs.mkdirSync(brainDir, { recursive: true });
@@ -1529,9 +1567,9 @@ function verifyBrain(root) {
 
 function brainUsageLines() {
   return [
-    'Usage: atris brain compile [--root <workspace>] [--verify] [--json]',
-    '       atris brain activate [--member <slug>] [--root <workspace>] [--verify] [--json]',
-    '       atris brain gallery [--root <workspace>] [--verify] [--json]',
+    'Usage: atris brain compile [--root <workspace>] [--yes] [--verify] [--json]',
+    '       atris brain activate [--member <slug>] [--root <workspace>] [--yes] [--verify] [--json]',
+    '       atris brain gallery [--root <workspace>] [--yes] [--verify] [--json]',
     '       atris brain go|hold [note] [--recommendation <text>] [--root <workspace>] [--verify]',
     '       atris brain approval go|edit|hold [note] [--recommendation <text>] [--root <workspace>] [--verify]',
     '       atris brain scorecard [--root <workspace>] [--verify] [--json]',
@@ -1618,6 +1656,10 @@ function brainCommand(args = process.argv.slice(3)) {
 
   if (subcommand === 'activate') {
     const state = prepareBrainState(options.root);
+    if (!options.yes) {
+      refuseBrainWriteWithoutYes(state, options);
+      return 0;
+    }
     writeBrain(state);
     if (options.verify) verifyBrain(options.root);
     const card = renderActivationCard(state, options);
@@ -1636,7 +1678,7 @@ function brainCommand(args = process.argv.slice(3)) {
         }
       }
       console.log(JSON.stringify({ ok: true, state, card }, null, 2));
-      return;
+      return 0;
     }
     console.log('');
     console.log(card);
@@ -1645,7 +1687,7 @@ function brainCommand(args = process.argv.slice(3)) {
         verifyActivationCard(card);
       } catch (error) {
         printVerifyFailure(error);
-        return;
+        return 1;
       }
       const operator = (card.match(/^OPERATOR:\s*(.+)$/m) || [null, 'unknown'])[1];
       if (operator === 'unknown') {
@@ -1655,10 +1697,14 @@ function brainCommand(args = process.argv.slice(3)) {
       }
     }
     console.log('');
-    return;
+    return 0;
   }
   if (subcommand === 'gallery') {
     const state = prepareBrainState(options.root);
+    if (!options.yes) {
+      refuseBrainWriteWithoutYes(state, options);
+      return 0;
+    }
     writeBrain(state);
     if (options.verify) verifyBrain(options.root);
     const gallery = renderActivationGallery(state);
@@ -1676,18 +1722,18 @@ function brainCommand(args = process.argv.slice(3)) {
           process.exit(1);
         }
         printVerifyFailure(error);
-        return;
+        return 1;
       }
     }
     if (options.json) {
       console.log(JSON.stringify({ ok: true, members: listMemberSlugs(options.root), gallery }, null, 2));
-      return;
+      return 0;
     }
     console.log('');
     console.log(gallery);
     if (options.verify) console.log('\nVERIFY: brain artifacts and member readiness present');
     console.log('');
-    return;
+    return 0;
   }
   if (subcommand !== 'compile' && subcommand !== 'status') {
     if (options.json) {
@@ -1703,12 +1749,16 @@ function brainCommand(args = process.argv.slice(3)) {
   }
 
   const state = prepareBrainState(options.root);
+  if (!options.yes) {
+    refuseBrainWriteWithoutYes(state, options);
+    return 0;
+  }
   const written = writeBrain(state);
   if (options.verify) verifyBrain(options.root);
 
   if (options.json) {
     console.log(JSON.stringify({ ok: true, state, written }, null, 2));
-    return;
+    return 0;
   }
 
   console.log('');
@@ -1720,6 +1770,7 @@ function brainCommand(args = process.argv.slice(3)) {
   console.log(`  Next: ${nextMove(state)}`);
   if (options.verify) console.log('  Verify: passed');
   console.log('');
+  return 0;
 }
 
 module.exports = {

package/commands/brainstorm.js

@@ -14,6 +14,7 @@ const {
 const { loadConfig } = require('../utils/config');
 const { loadCredentials, ensureValidCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const { isNonInteractive } = require('../lib/noninteractive');
 const { planAtris, doAtris, reviewAtris } = require('./workflow');
 
 const pkg = require('../package.json');
@@ -27,10 +28,12 @@ async function brainstormAtris() {
     console.log('Description:');
     console.log('  Guided prompt generator for exploration before planning.');
     console.log('  Default is local-first; pass --cloud to include AtrisOS journal context.');
+    console.log('  Headless agents: pass the idea on the command line (never prompts).');
     console.log('');
     console.log('Options:');
     console.log('  --cloud      Include AtrisOS journal context (optional).');
     console.log('  --no-cloud   Force local-only mode (skip AtrisOS).');
+    console.log('  --yes        Non-interactive: capture idea args and exit.');
     console.log('');
     return;
   }
@@ -49,6 +52,21 @@ async function brainstormAtris() {
   const useCloudJournal = args.includes('--cloud') && !args.includes('--no-cloud');
   const topicFromArgs = args.filter((arg) => !arg.startsWith('-')).join(' ').trim() || null;
 
+  // Headless agents must never hang on "Describe the desired outcome".
+  if (isNonInteractive(args)) {
+    if (topicFromArgs) {
+      const newId = addInboxIdea(logFile, topicFromArgs);
+      console.log(`captured I${newId}: ${topicFromArgs}`);
+      console.log(`journal: ${path.relative(process.cwd(), logFile) || logFile}`);
+      console.log('Next: atris plan');
+      return;
+    }
+    console.log('brainstorm is interactive without an idea on the command line.');
+    console.log(`journal: ${path.relative(process.cwd(), logFile) || logFile}`);
+    console.log('Next: atris brainstorm "<idea>"');
+    return;
+  }
+
   console.log('');
   console.log('┌─────────────────────────────────────────────────────────────┐');
   console.log('│ Atris Brainstorm — structured prompt generator              │');

package/commands/business.js

@@ -35,6 +35,7 @@ function isHelpToken(arg) {
 }
 
 const BUSINESS_CREATE_USAGE = 'Usage: atris business create <name> [--description "..."] [--workspace] [--here|--root <dir>]';
+const BUSINESS_SHIP_USAGE = 'Usage: atris business ship "<paragraph>" [--name <name>] [--email <email>] --yes';
 
 function isAccidentalHelpBusiness(value) {
   const raw = String(value || '').trim();
@@ -70,6 +71,75 @@ function validateBusinessCreateName(name) {
   return { ok: true };
 }
 
+function compactShipText(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function parseBusinessShipArgs(args = []) {
+  const positional = [];
+  let name = '';
+  let email = '';
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+
+    if (arg === '--name') {
+      if (!next || String(next).startsWith('-')) {
+        return { ok: false, usage: BUSINESS_SHIP_USAGE, detail: 'Missing value for --name.' };
+      }
+      name = next;
+      i++;
+    } else if (typeof arg === 'string' && arg.startsWith('--name=')) {
+      name = arg.slice('--name='.length);
+    } else if (arg === '--email') {
+      if (!next || String(next).startsWith('-')) {
+        return { ok: false, usage: BUSINESS_SHIP_USAGE, detail: 'Missing value for --email.' };
+      }
+      email = next;
+      i++;
+    } else if (typeof arg === 'string' && arg.startsWith('--email=')) {
+      email = arg.slice('--email='.length);
+    } else if (arg === '--yes' || arg === '-y') {
+      // proceed flag; checked by shipBusiness
+    } else if (typeof arg === 'string' && arg.startsWith('-')) {
+      return { ok: false, usage: BUSINESS_SHIP_USAGE, detail: `Unknown option: ${arg}` };
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  const description = compactShipText(positional.join(' '));
+  if (!description) {
+    return { ok: false, usage: BUSINESS_SHIP_USAGE };
+  }
+
+  return {
+    ok: true,
+    description,
+    name: compactShipText(name),
+    email: compactShipText(email),
+  };
+}
+
+function shipTeamNames(team) {
+  const rows = Array.isArray(team)
+    ? team
+    : (Array.isArray(team?.members) ? team.members : []);
+  return rows.map((member) => {
+    if (typeof member === 'string') return compactShipText(member);
+    if (!member || typeof member !== 'object') return '';
+    return compactShipText(member.display_name || member.name || member.slug || '');
+  }).filter(Boolean);
+}
+
+function shipTaskTitle(task) {
+  if (!task) return '';
+  if (typeof task === 'string') return compactShipText(task);
+  if (typeof task !== 'object') return '';
+  return compactShipText(task.title || task.name || '');
+}
+
 function loadBusinesses() {
   const p = getBusinessConfigPath();
   if (!fs.existsSync(p)) return {};
@@ -2789,6 +2859,73 @@ async function initBusinessWorkspace(name, ...flags) {
   return createBusinessInternal(name, flags, 'canonical');
 }
 
+function printBusinessShipHelp() {
+  console.log(BUSINESS_SHIP_USAGE);
+  console.log('');
+  console.log('Create a live business from one paragraph.');
+  console.log('  --name <name>     Optional business name');
+  console.log('  --email <email>   Optional customer email');
+  console.log('  --yes             Required to POST /business/ship');
+}
+
+async function shipBusiness(...args) {
+  if (args.some(isHelpToken)) {
+    printBusinessShipHelp();
+    return;
+  }
+
+  if (!args.includes('--yes') && !args.includes('-y')) {
+    console.error(BUSINESS_SHIP_USAGE);
+    console.error('Pass --yes to create a live business.');
+    process.exit(2);
+  }
+
+  const parsed = parseBusinessShipArgs(args);
+  if (!parsed.ok) {
+    console.error(parsed.usage);
+    if (parsed.detail) console.error(`\n  ${parsed.detail}`);
+    process.exit(1);
+  }
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  const body = { description: parsed.description };
+  if (parsed.name) body.name = parsed.name;
+  if (parsed.email) body.customer_email = parsed.email;
+
+  console.log(`Shipping business: ${parsed.name || parsed.description}...`);
+
+  const result = await apiRequestJson('/business/ship', {
+    method: 'POST',
+    token: creds.token,
+    body,
+  });
+
+  if (!result.ok) {
+    console.error(`Failed: ${result.errorMessage || result.error || result.status}`);
+    process.exit(1);
+  }
+
+  const payload = result.data || {};
+  const slug = payload.slug || '';
+  const label = payload.name || parsed.name || slug || 'business';
+  const pageUrl = payload.public_page_url || '';
+  const names = shipTeamNames(payload.team);
+  const firstTask = shipTaskTitle(payload.seeded_task);
+
+  console.log('');
+  console.log(`  ${label}${slug ? ` (${slug})` : ''}`);
+  if (pageUrl) console.log(`  Public page: ${pageUrl}`);
+  if (names.length > 0) console.log(`  Team: ${names.join(', ')}`);
+  if (firstTask) console.log(`  First task: ${firstTask}`);
+  console.log('');
+  return payload;
+}
+
 
 async function businessStatus(slug) {
   const creds = loadCredentials();
@@ -3364,6 +3501,7 @@ function printBusinessHelp() {
   console.log('  init <name>          RECOMMENDED: create a business environment (cloud + local)');
   console.log('  workspace <name>     Alias for init');
   console.log('  create <name>        Cloud-only business record; add --workspace to also scaffold local');
+  console.log('  ship "<paragraph>"   One paragraph, live business (optional --name, --email; --yes required)');
   console.log('  simulate <idea>      Create a business, four-role team, missions, and endgame loop');
   console.log('  add <slug>           Register an existing cloud business');
   console.log('  list                 Show registered businesses');
@@ -3401,7 +3539,11 @@ async function businessCommand(subcommand, ...args) {
     printBusinessSimulateHelp();
     return;
   }
-  const nameTakingSubcommands = new Set(['create', 'new', 'init', 'workspace']);
+  if (subcommand === 'ship' && args.some(isHelpToken)) {
+    printBusinessShipHelp();
+    return;
+  }
+  const nameTakingSubcommands = new Set(['create', 'new', 'init', 'workspace', 'ship']);
   if (nameTakingSubcommands.has(subcommand) && args.some(isHelpToken)) {
     printBusinessHelp();
     return;
@@ -3419,6 +3561,9 @@ async function businessCommand(subcommand, ...args) {
     case 'new':
       await createBusiness(args[0], ...args.slice(1));
       break;
+    case 'ship':
+      await shipBusiness(...args);
+      break;
     case 'init':
     case 'workspace':
       await initBusinessWorkspace(args[0], ...args.slice(1));
@@ -3523,6 +3668,9 @@ module.exports = {
   businessMatchesSlug,
   isAccidentalHelpBusiness,
   validateBusinessCreateName,
+  parseBusinessShipArgs,
+  shipTeamNames,
+  shipTaskTitle,
   analyzeBusinessDoctor,
   createCanonicalBusinessWorkspace,
   onboardBusiness,

package/commands/chat-scan.js

@@ -2,6 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const { hasFlag } = require('../lib/arg-parser');
 const { scanChatLogs, writeLatestScan } = require('../lib/chat-log-scan');
+const { parseScopeFlag } = require('../lib/cli-scope');
+const { requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
 
 // Preserve the existing rule that the next token is a value, even if it is a flag.
 function readFollowingFlag(args, name, fallback) {
@@ -57,7 +59,7 @@ function printReport(report) {
 function chatScanCommand(argv = []) {
   const args = argv.filter((a) => a !== '--');
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
-    console.log(`Usage: atris chat scan [--json] [--hours <n>] [--limit <n>] [--no-write]
+    console.log(`Usage: atris chat scan [--json] [--hours <n>] [--limit <n>] [--no-write] [--global]
 
 Read recent ax chat logs and Cursor agent transcripts; surface friction/errors.
 
@@ -65,10 +67,20 @@ Options:
   --hours <n>   Lookback window (default 720 = 30 days)
   --limit <n>   Max sessions per source (default 12)
   --no-write    Skip writing .atris/state/chat_scan.latest.json
-  --json        Machine-readable output`);
+  --json        Machine-readable output
+  --global      Include ~/.atris/runs (unbound folders need --account)`);
     return { ok: true };
   }
 
+  const scope = parseScopeFlag(args);
+  if (scope.global) {
+    const gate = requireAccountBound(scope.args);
+    if (!gate.ok) {
+      refuseAccountGlobal();
+      process.exit(2);
+    }
+  }
+
   const root = process.cwd();
   if (!fs.existsSync(path.join(root, 'atris'))) {
     console.error('✗ atris/ folder not found. Run from an Atris workspace.');
@@ -77,8 +89,9 @@ Options:
 
   const report = scanChatLogs({
     cwd: root,
-    hours: readFollowingFlag(args, '--hours', 720),
-    limit: readFollowingFlag(args, '--limit', 12),
+    hours: readFollowingFlag(scope.args, '--hours', 720),
+    limit: readFollowingFlag(scope.args, '--limit', 12),
+    global: scope.global,
   });
 
   let latestPath = null;

package/commands/close.js

@@ -1239,7 +1239,11 @@ function run(args = [], context = {}) {
   const subcommand = args[0];
   const rest = args.slice(1);
   try {
-    if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    if (!subcommand) {
+      printHelp();
+      return 2;
+    }
+    if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
       printHelp();
       return 0;
     }

package/commands/computer.js

@@ -2141,7 +2141,7 @@ async function runBusinessPromptViaRunnerProxy(token, ctx, prompt, options = {})
   const payload = {
     prompt,
     permission_mode: 'bypassPermissions',
-    max_turns: Math.min(Math.max(Number(options.maxTurns || 12), 1), 25),
+    max_turns: Math.min(Math.max(Number(options.maxTurns || 40), 1), 100),
     reset_context: Boolean(options.resetContext),
   };
   if (options.worker) payload.worker = options.worker;
@@ -3399,7 +3399,7 @@ async function sendBusinessChat(token, ctx, message, sessionId, resetContext = f
     const fallback = await runBusinessPromptViaRunnerProxy(token, ctx, message, {
       ...options,
       resetContext,
-      maxTurns: 25,
+      maxTurns: 60,
     });
     if (!fallback.ok) {
       if (typeof options.onFailure === 'function') {