atris 3.15.30 → 3.15.36

package/commands/computer.js

@@ -3,8 +3,10 @@
  *
  *   atris computer                  — Open SMART mode (cloud in business workspace, local elsewhere)
  *   atris computer --cloud          — Open CLOUD workspace mode
+ *   atris computer create <name>    — Create and wake a business computer
  *   atris computer wake             — Start the computer
  *   atris computer sleep            — Stop (files persist)
+ *   atris computer delete           — Sleep, confirm, and delete a business computer
  *   atris computer card             — Show the local computer card
  *   atris computer run <command>    — Run bash on EC2 (no LLM)
  *   atris computer grep <pattern>   — Search files on EC2
@@ -19,10 +21,11 @@ const path = require('path');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
 const { loadCredentials, decodeJwtClaims } = require('../utils/auth');
-const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
+const { apiRequestJson, getApiBaseUrl, getAppBaseUrl } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
 const { consoleCommand, gatherAtrisContext, buildSystemPrompt } = require('./console');
 const { streamSession } = require('./serve');
+const { buildRemoteAtrisBootstrapCommand } = require('../lib/runtime-bootstrap');
 
 function getToken() {
   const creds = loadCredentials();
@@ -149,6 +152,38 @@ function formatBillingMode(worker) {
     : 'Claude subscription lane';
 }
 
+function extractAttachedWorkspaceMismatch(...values) {
+  const text = values
+    .filter((value) => value !== null && value !== undefined)
+    .map((value) => {
+      if (typeof value === 'string') return value;
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    })
+    .join('\n');
+  const match = text.match(/attached to workspace\s+([a-z0-9-]+)\.\s*Activate workspace\s+([a-z0-9-]+)\s+to switch/i);
+  if (!match) return null;
+  return {
+    attachedWorkspaceId: match[1],
+    requestedWorkspaceId: match[2],
+  };
+}
+
+function contextForAttachedWorkspaceMismatch(ctx, failure) {
+  const mismatch = extractAttachedWorkspaceMismatch(
+    failure?.result?.error,
+    failure?.result?.errorMessage,
+    failure?.result?.data,
+    failure?.fallback?.error,
+    failure?.fallback?.payload
+  );
+  if (!mismatch?.attachedWorkspaceId || mismatch.attachedWorkspaceId === ctx?.workspaceId) return null;
+  return { ...ctx, workspaceId: mismatch.attachedWorkspaceId };
+}
+
 async function describeClaudeAuth(token, ctx) {
   try {
     const status = await fetchBusinessClaudeLoginStatus(token, ctx);
@@ -505,9 +540,33 @@ function parseComputerOptions(argv) {
   const positional = [];
   let worker = process.env.ATRIS_CLOUD_WORKER || null;
   let model = process.env.ATRIS_CLOUD_MODEL || null;
+  let businessSlug = null;
+  let workspaceId = null;
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
+    if ((arg === '--business' || arg === '-b') && argv[i + 1]) {
+      businessSlug = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--business=')) {
+      businessSlug = arg.split('=', 2)[1] || null;
+      continue;
+    }
+    if ((arg === '--workspace' || arg === '--workspace-id') && argv[i + 1]) {
+      workspaceId = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--workspace=')) {
+      workspaceId = arg.split('=', 2)[1] || null;
+      continue;
+    }
+    if (arg.startsWith('--workspace-id=')) {
+      workspaceId = arg.split('=', 2)[1] || null;
+      continue;
+    }
     if (arg === '--worker' && argv[i + 1]) {
       worker = argv[i + 1];
       i++;
@@ -540,10 +599,65 @@ function parseComputerOptions(argv) {
     options: {
       worker: worker || null,
       model: model || null,
+      businessSlug: businessSlug ? String(businessSlug).trim() : null,
+      workspaceId: workspaceId ? String(workspaceId).trim() : null,
     },
   };
 }
 
+function parseComputerCreateArgs(argv = []) {
+  const nameParts = [];
+  let businessSlug = null;
+  let help = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      help = true;
+      continue;
+    }
+    if ((arg === '--business' || arg === '-b') && argv[i + 1]) {
+      businessSlug = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--business=')) {
+      businessSlug = arg.split('=', 2)[1] || null;
+      continue;
+    }
+    nameParts.push(arg);
+  }
+
+  return {
+    name: nameParts.join(' ').trim(),
+    businessSlug: businessSlug ? String(businessSlug).trim() : null,
+    help,
+  };
+}
+
+function parseComputerDeleteArgs(argv = []) {
+  const options = { help: false, confirm: null };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--confirm' && argv[i + 1]) {
+      options.confirm = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--confirm=')) {
+      options.confirm = arg.slice('--confirm='.length);
+      continue;
+    }
+  }
+
+  return options;
+}
+
 function formatCloudSelection(options = {}) {
   const worker = activeWorker(options.worker);
   const parts = [`worker=${worker}`];
@@ -923,8 +1037,32 @@ async function resolveBusinessContext(token) {
   return null;
 }
 
-async function resolveBusinessContextBySlug(token, slug) {
+function cachedBusinessContext(slug) {
   if (!slug) return null;
+  const wanted = String(slug).toLowerCase();
+  const businesses = loadBusinesses();
+  const cached = businesses[slug] || Object.values(businesses).find((entry) => {
+    if (!entry) return false;
+    return String(entry.slug || '').toLowerCase() === wanted
+      || String(entry.canonical_slug || '').toLowerCase() === wanted
+      || String(entry.name || '').toLowerCase() === wanted;
+  });
+  if (!cached?.business_id) return null;
+  return {
+    slug: cached.slug || slug,
+    businessId: cached.business_id,
+    workspaceId: cached.workspace_id || null,
+    businessName: cached.name || cached.slug || slug,
+  };
+}
+
+async function resolveBusinessContextBySlug(token, slug, options = {}) {
+  if (!slug) return null;
+
+  if (options.preferCache) {
+    const cached = cachedBusinessContext(slug);
+    if (cached?.workspaceId) return cached;
+  }
 
   const businesses = loadBusinesses();
   const list = await apiRequestJson('/business/', { method: 'GET', token });
@@ -953,6 +1091,70 @@ async function resolveBusinessContextBySlug(token, slug) {
   return null;
 }
 
+async function resolveComputerCommandContext(token, options = {}) {
+  if (options.businessSlug || options.workspaceId) {
+    const ctx = options.businessSlug
+      ? await resolveBusinessContextBySlug(token, options.businessSlug, { preferCache: true })
+      : await resolveBusinessContext(token);
+    if (!ctx?.businessId) return null;
+    return {
+      ...ctx,
+      workspaceId: options.workspaceId || ctx.workspaceId,
+    };
+  }
+
+  return resolveBusinessContext(token);
+}
+
+async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
+  const wantedSlug = businessSlug ? String(businessSlug).trim() : null;
+  if (wantedSlug) {
+    const fromApi = await resolveBusinessContextBySlug(token, wantedSlug);
+    if (fromApi) return fromApi;
+
+    const cached = loadBusinesses()[wantedSlug];
+    if (cached?.business_id) {
+      return {
+        slug: cached.slug || wantedSlug,
+        businessId: cached.business_id,
+        workspaceId: cached.workspace_id || null,
+        businessName: cached.name || cached.slug || wantedSlug,
+      };
+    }
+    return null;
+  }
+
+  const binding = readBusinessBinding();
+  if (binding?.business_id) {
+    return {
+      slug: binding.slug || binding.canonical_slug || null,
+      businessId: binding.business_id,
+      workspaceId: binding.workspace_id || null,
+      businessName: binding.name || binding.slug || 'business',
+    };
+  }
+
+  return resolveBusinessContext(token);
+}
+
+function rememberCreatedComputer(ctx, workspace, endpoint = null) {
+  const slug = ctx.slug || (ctx.businessName || '').toLowerCase().replace(/\s+/g, '-');
+  if (!slug) return;
+  const businesses = loadBusinesses();
+  businesses[slug] = {
+    ...(businesses[slug] || {}),
+    business_id: ctx.businessId,
+    workspace_id: workspace.id,
+    name: ctx.businessName,
+    slug,
+    computer_name: workspace.name,
+    endpoint: endpoint || undefined,
+    added_at: businesses[slug]?.added_at || new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+  saveBusinesses(businesses);
+}
+
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
@@ -974,6 +1176,42 @@ async function runBusinessTerminalCommand(token, ctx, command, timeout = 30) {
   );
 }
 
+async function bootstrapBusinessComputerRuntime(token, ctx, boundary = 'computer-wake') {
+  if (!ctx?.businessId || !ctx?.workspaceId) {
+    return { ok: false, skipped: true, reason: 'missing_workspace' };
+  }
+  if (process.env.ATRIS_SKIP_RUNTIME_BOOTSTRAP === '1') {
+    return { ok: true, skipped: true, reason: 'env' };
+  }
+
+  const command = buildRemoteAtrisBootstrapCommand({
+    boundary,
+    businessSlug: ctx.slug || '',
+    businessId: ctx.businessId,
+    workspaceId: ctx.workspaceId,
+  });
+  const result = await runBusinessTerminalCommand(token, ctx, command, 120);
+  if (!result.ok) {
+    console.log('  Runtime: bootstrap could not run.');
+    console.log(`  Recovery: atris computer run "npm install -g atris@latest" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+    return { ok: false, result };
+  }
+
+  const data = result.data || {};
+  const output = String(data.stdout || data.output || data.result || '').trim();
+  const line = output.split('\n').find((entry) => entry.includes('atris_runtime_bootstrap'));
+  const recovery = output.split('\n').find((entry) => entry.startsWith('recovery='));
+  if (line) {
+    console.log(`  Runtime: ${line.replace(/^atris_runtime_bootstrap\s*/, '')}`);
+  } else {
+    console.log('  Runtime: Atris bootstrap receipt written.');
+  }
+  if (recovery) {
+    console.log(`  Recovery: atris computer run "${recovery.slice('recovery='.length)}" --business ${ctx.slug || ctx.businessId} --workspace ${ctx.workspaceId}`);
+  }
+  return { ok: true, output };
+}
+
 async function readBusinessWorkspaceFile(token, ctx, remotePath, timeoutMs = 15000) {
   return apiRequestJson(
     `/business/${ctx.businessId}/workspaces/${ctx.workspaceId}/file?path=${encodeURIComponent(remotePath)}`,
@@ -1137,6 +1375,7 @@ async function ensureBusinessAwake(token, ctx, maxWaitSec = 90) {
     if (next.ok && next.data && next.data.status === 'running' && next.data.endpoint) {
       const elapsed = Math.floor((Date.now() - start) / 1000);
       console.log(`awake (${elapsed}s)`);
+      await bootstrapBusinessComputerRuntime(token, ctx, 'computer-auto-wake');
       return true;
     }
   }
@@ -1207,6 +1446,8 @@ async function computerWake(token, ctx = null) {
     }
     console.log(`  Status:   ${result.data.status}`);
     if (result.data.endpoint) console.log(`  Endpoint: ${result.data.endpoint}`);
+    await bootstrapBusinessComputerRuntime(token, ctx, 'computer-wake');
+    console.log('  Computer is awake.');
     return;
   }
 
@@ -1222,6 +1463,106 @@ async function computerWake(token, ctx = null) {
   }
   console.log(`  Status:   ${result.data.status}`);
   console.log(`  Endpoint: ${result.data.endpoint}`);
+  console.log('  Computer is awake.');
+}
+
+async function computerCreate(token, args = [], defaults = {}) {
+  const options = parseComputerCreateArgs(args);
+  if (!options.businessSlug && defaults.businessSlug) {
+    options.businessSlug = defaults.businessSlug;
+  }
+  if (options.help || !options.name) {
+    console.log('Usage: atris computer create <name> --business <slug>');
+    console.log('');
+    console.log('Create a business computer, activate it, and wake it in one command.');
+    console.log('');
+    console.log('Examples:');
+    console.log('  atris computer create "My Business Computer" --business atris-labs');
+    console.log('  atris computer create "Recruiting Computer"');
+    if (!options.name && !options.help) process.exitCode = 1;
+    return;
+  }
+
+  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug);
+  if (!ctx?.businessId) {
+    console.error('No business found.');
+    console.error('Run inside a bound business workspace or pass: --business <slug>');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`Creating computer "${options.name}" for ${ctx.businessName}...`);
+  const created = await apiRequestJson(`/business/${ctx.businessId}/workspaces`, {
+    method: 'POST',
+    token,
+    body: { name: options.name, type: 'general' },
+  });
+  if (!created.ok) {
+    console.error(`Failed to create workspace: ${created.errorMessage || created.error || created.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const workspace = created.data || {};
+  const workspaceId = workspace.id || workspace.workspace_id;
+  if (!workspaceId) {
+    console.error('Failed to create workspace: response did not include workspace id');
+    process.exitCode = 1;
+    return;
+  }
+
+  const activate = await apiRequestJson(`/business/${ctx.businessId}/workspaces/${workspaceId}/activate`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!activate.ok && activate.status !== 409) {
+    console.error(`Failed to activate computer: ${activate.errorMessage || activate.error || activate.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const wake = await apiRequestJson(`/business/${ctx.businessId}/ai-computer/wake`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!wake.ok && !activate.ok) {
+    console.error(`Failed to wake computer: ${wake.errorMessage || wake.error || wake.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const endpoint = activate.data?.endpoint || wake.data?.endpoint || null;
+  const status = endpoint
+    ? 'running'
+    : (wake.data?.status || (activate.ok ? 'activated' : 'warming_up'));
+  rememberCreatedComputer(ctx, { ...workspace, id: workspaceId, name: workspace.name || options.name }, endpoint);
+  await bootstrapBusinessComputerRuntime(token, { ...ctx, workspaceId }, 'computer-create');
+
+  const appBase = getAppBaseUrl();
+  console.log('');
+  console.log(`Computer created: ${workspaceId}`);
+  console.log(`  Name:      ${workspace.name || options.name}`);
+  console.log(`  Business:  ${ctx.businessName}`);
+  console.log(`  Status:    ${status}`);
+  if (endpoint) console.log(`  Endpoint:  ${endpoint}`);
+  console.log(`  Dashboard: ${appBase}/dashboard/gm/${ctx.businessId}`);
+  console.log('');
+  const owner = ctx.slug || ctx.businessId;
+  console.log('Start here:');
+  console.log(`  atris computer --business ${owner} --workspace ${workspaceId}`);
+  console.log('');
+  console.log('Org workspace:');
+  console.log(`  cd ~/arena/atris-business/${owner}`);
+  console.log('  atris member activate operator');
+  console.log('  atris member activate validator');
+  console.log('');
+  console.log('If the org workspace does not exist yet:');
+  console.log(`  atris business init "${ctx.businessName}"`);
+  console.log('');
+  console.log('Cost control:');
+  console.log(`  atris computer sleep --business ${owner} --workspace ${workspaceId}`);
 }
 
 async function computerSleep(token, ctx = null) {
@@ -1237,6 +1578,7 @@ async function computerSleep(token, ctx = null) {
       return;
     }
     console.log('  Computer is sleeping. Files persist.');
+    console.log('  No compute cost while sleeping.');
     return;
   }
 
@@ -1251,6 +1593,113 @@ async function computerSleep(token, ctx = null) {
     return;
   }
   console.log('  Computer is sleeping. Files persist.');
+  console.log('  No compute cost while sleeping.');
+}
+
+function rememberDeletedComputer(ctx) {
+  const businesses = loadBusinesses();
+  let changed = false;
+  for (const [slug, entry] of Object.entries(businesses)) {
+    if (!entry) continue;
+    const sameBusiness = entry.business_id === ctx.businessId || slug === ctx.slug;
+    const sameWorkspace = entry.workspace_id === ctx.workspaceId;
+    if (sameBusiness && sameWorkspace) {
+      delete entry.workspace_id;
+      delete entry.computer_name;
+      delete entry.endpoint;
+      entry.deleted_workspace_id = ctx.workspaceId;
+      entry.updated_at = new Date().toISOString();
+      changed = true;
+    }
+  }
+  if (changed) saveBusinesses(businesses);
+}
+
+async function confirmComputerDelete(ctx, options) {
+  const expected = `delete ${ctx.workspaceId}`;
+  if (String(options.confirm || '').trim() === expected) return true;
+
+  console.log('');
+  console.log('This will sleep the computer first, then delete the workspace record.');
+  console.log(`Business:  ${ctx.businessName}`);
+  console.log(`Workspace: ${ctx.workspaceId}`);
+  console.log(`Type "${expected}" to continue.`);
+
+  if (!useInteractiveTerminalUi()) {
+    console.error(`Confirmation required. Re-run with: --confirm "${expected}"`);
+    return false;
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = String(await questionAsync(rl, 'Confirm: ') || '').trim();
+  rl.close();
+  if (answer === expected) return true;
+
+  console.error('Delete cancelled.');
+  return false;
+}
+
+async function computerDelete(token, ctx, options = {}, args = []) {
+  const deleteOptions = parseComputerDeleteArgs(args);
+  if (deleteOptions.help) {
+    console.log('Usage: atris computer delete --business <slug> --workspace <workspace-id>');
+    console.log('');
+    console.log('Sleeps the computer first, then deletes the non-default workspace after confirmation.');
+    console.log('');
+    console.log('Examples:');
+    console.log('  atris computer delete --business atris-labs --workspace ws_123');
+    console.log('  atris computer delete --business atris-labs --workspace ws_123 --confirm "delete ws_123"');
+    return;
+  }
+
+  if (!ctx?.businessId) {
+    console.error('No business found.');
+    console.error('Pass: --business <slug> --workspace <workspace-id>');
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!options.workspaceId || !ctx.workspaceId) {
+    console.error('Refusing to delete without an explicit workspace id.');
+    console.error('Pass: --workspace <workspace-id>');
+    process.exitCode = 1;
+    return;
+  }
+
+  const confirmed = await confirmComputerDelete(ctx, deleteOptions);
+  if (!confirmed) {
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`Sleeping computer for ${ctx.businessName}...`);
+  const slept = await apiRequestJson(`/business/${ctx.businessId}/ai-computer/sleep`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!slept.ok) {
+    console.error(`Failed to sleep computer: ${slept.errorMessage || slept.error || slept.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('  Computer is sleeping. Files persist.');
+  console.log(`Deleting workspace ${ctx.workspaceId}...`);
+  const deleted = await apiRequestJson(`/business/${ctx.businessId}/workspaces/${ctx.workspaceId}`, {
+    method: 'DELETE',
+    token,
+  });
+  if (!deleted.ok) {
+    console.error(`Failed to delete computer: ${deleted.errorMessage || deleted.error || deleted.status}`);
+    if (deleted.status === 400) console.error('Default workspaces cannot be deleted.');
+    process.exitCode = 1;
+    return;
+  }
+
+  rememberDeletedComputer(ctx);
+  console.log('  Computer deleted.');
+  console.log('  Cost gate: sleeping before delete completed.');
 }
 
 async function computerRun(token, command, ctx = null) {
@@ -1941,6 +2390,9 @@ async function sendBusinessChat(token, ctx, message, sessionId, resetContext = f
       maxTurns: 25,
     });
     if (!fallback.ok) {
+      if (typeof options.onFailure === 'function') {
+        options.onFailure({ result, fallback });
+      }
       console.error(`Failed: ${result.error || result.status}`);
       if (fallback.error) {
         console.error(`Fallback failed: ${fallback.error}`);
@@ -2452,12 +2904,33 @@ async function computerProof(token, ctx, initialOptions = {}) {
 
     console.log(ui.bold('Run'));
     console.log(`  prompt: ${prompt}`);
-    const nextSessionId = await sendBusinessChat(token, ctx, prompt, sessionId, true, null, {
+    let activeCtx = ctx;
+    let chatFailure = null;
+    let nextSessionId = await sendBusinessChat(token, activeCtx, prompt, sessionId, true, null, {
       worker,
       model,
       systemPrompt,
       localCliSessionId: bridge.sessionId,
+      onFailure: (failure) => {
+        chatFailure = failure;
+      },
     });
+    const retryCtx = contextForAttachedWorkspaceMismatch(activeCtx, chatFailure);
+    if (retryCtx) {
+      console.log('');
+      console.log(`Retrying proof against attached workspace ${retryCtx.workspaceId}...`);
+      activeCtx = retryCtx;
+      chatFailure = null;
+      nextSessionId = await sendBusinessChat(token, activeCtx, prompt, `${sessionId}-attached`, true, null, {
+        worker,
+        model,
+        systemPrompt,
+        localCliSessionId: bridge.sessionId,
+        onFailure: (failure) => {
+          chatFailure = failure;
+        },
+      });
+    }
 
     const localPath = path.join(bridge.workingDir, fileName);
     let localContent = '';
@@ -2468,10 +2941,10 @@ async function computerProof(token, ctx, initialOptions = {}) {
     }
     const localOk = localContent === expected;
 
-    const cloudFile = await readBusinessWorkspaceFile(token, ctx, fileName, 15000);
+    const cloudFile = await readBusinessWorkspaceFile(token, activeCtx, fileName, 15000);
     const cloudClear = !cloudFile.ok && cloudFile.status === 404;
 
-    const audit = await fetchBusinessChatAudit(token, ctx, 5);
+    const audit = await fetchBusinessChatAudit(token, activeCtx, 5);
     const rows = audit.ok ? (audit.data?.rows || []) : [];
     const auditRow = rows.find((row) => row.session_id === nextSessionId || row.preview?.includes(fileName)) || rows[0] || {};
     const auditOk = audit.ok && auditRow.status === 'completed' && String(auditRow.result_preview || '').includes('ATRIS COMPUTER PROOF OK');
@@ -2505,6 +2978,13 @@ async function runComputer() {
   const sub = args[0];
 
   if (!sub) {
+    if (cloudOptions.businessSlug || cloudOptions.workspaceId) {
+      const token = getToken();
+      const ctx = await resolveComputerCommandContext(token, cloudOptions);
+      await computerChat(token, ctx, cloudOptions);
+      return;
+    }
+
     const hasBusinessBinding = Boolean(readBusinessBinding());
     const hasLocalHarness = Boolean(findAtrisCodeTerminal());
     const surface = await chooseComputerSurface(hasBusinessBinding, hasLocalHarness);
@@ -2531,7 +3011,7 @@ async function runComputer() {
 
   if (sub === '--local' || sub === 'local') {
     const token = getToken();
-    const ctx = await resolveBusinessContext(token);
+    const ctx = await resolveComputerCommandContext(token, cloudOptions);
     if (ctx) {
       await computerLocalAtris(token, ctx, cloudOptions);
       return;
@@ -2542,7 +3022,7 @@ async function runComputer() {
 
   if (sub === 'local-atris') {
     const token = getToken();
-    const ctx = await resolveBusinessContext(token);
+    const ctx = await resolveComputerCommandContext(token, cloudOptions);
     await computerLocalAtris(token, ctx, cloudOptions);
     return;
   }
@@ -2562,6 +3042,14 @@ async function runComputer() {
     return;
   }
 
+  if (sub === 'create') {
+    const createOptions = parseComputerCreateArgs(args.slice(1));
+    if (createOptions.help || !createOptions.name) {
+      await computerCreate(null, args.slice(1));
+      return;
+    }
+  }
+
   if (sub === '--help') {
     console.log('Usage: atris computer [mode|command]');
     console.log('');
@@ -2588,19 +3076,23 @@ async function runComputer() {
     console.log('  --cloud         Open CLOUD workspace mode in the bound business workspace');
     console.log('  cloud           Open CLOUD workspace mode in the bound business workspace');
     console.log('  codeops         Open Atris CodeOps workflow computer if your account has access');
+    console.log('  --business      Select a business by slug');
+    console.log('  --workspace     Select a specific workspace/computer id');
     console.log('  --worker        Cloud worker override: claude | openai');
     console.log('  --model         Cloud model override');
     console.log('  claude|codex    Legacy local console backends');
     console.log('');
     console.log('Cloud commands:');
+    console.log('  create <name>    Create and wake an extra business computer');
     console.log('  chat            Interactive cloud workspace chat');
     console.log('                  Ctrl-C during a cloud run interrupts it');
     console.log('                  /start shows the beginner flow');
     console.log('                  /status shows lane, Claude auth, and billing');
     console.log('                  /audit [n] shows recent cloud runs inside chat');
     console.log('  status          Show computer status');
-    console.log('  wake            Start the computer');
+    console.log('  up|wake         Start the computer');
     console.log('  sleep           Stop the computer (files persist)');
+    console.log('  delete          Sleep, confirm, and delete a business computer');
     console.log('  run <cmd>       Run bash on EC2 (no LLM cost)');
     console.log('  grep <pattern>  Search files on EC2');
     console.log('  ls [path]       List files');
@@ -2614,7 +3106,11 @@ async function runComputer() {
     console.log('Examples:');
     console.log('  atris computer');
     console.log('  atris computer card --write');
-    console.log('  atris business init "My Lab"     # shared owner + first/default computer');
+    console.log('  atris business init "My Lab"     # first/default computer with Atris + operator');
+    console.log('  atris computer create "Recruiting Computer" --business atris-labs');
+    console.log('  atris computer --business atris-labs --workspace <workspace-id>');
+    console.log('  atris computer sleep --business atris-labs --workspace <workspace-id>');
+    console.log('  atris computer delete --business atris-labs --workspace <workspace-id>');
     console.log('  atris computer proof');
     console.log('  atris computer local');
     console.log('  atris computer codex');
@@ -2635,7 +3131,11 @@ async function runComputer() {
   }
 
   const token = getToken();
-  const ctx = await resolveBusinessContext(token);
+  if (sub === 'create') {
+    return computerCreate(token, args.slice(1), cloudOptions);
+  }
+
+  const ctx = await resolveComputerCommandContext(token, cloudOptions);
 
   if (sub === 'codeops') {
     const codeopsCtx = await resolveBusinessContextBySlug(token, 'atris-codeops');
@@ -2697,8 +3197,11 @@ async function runComputer() {
     case 'card': return computerCard(args.slice(1));
     case 'proof': return computerProof(token, ctx, cloudOptions);
     case 'status': return computerStatus(token, ctx);
+    case 'up':
     case 'wake': return computerWake(token, ctx);
     case 'sleep': return computerSleep(token, ctx);
+    case 'delete':
+    case 'rm': return computerDelete(token, ctx, cloudOptions, args.slice(1));
     case 'run': return computerRun(token, rest, ctx);
     case 'grep': return computerGrep(token, rest, ctx);
     case 'ls': return computerLs(token, rest || undefined, ctx);
@@ -2722,4 +3225,6 @@ module.exports = {
   buildComputerCard,
   renderComputerCard,
   renderComputerCardMarkdown,
+  extractAttachedWorkspaceMismatch,
+  contextForAttachedWorkspaceMismatch,
 };