atris 3.15.31 → 3.15.37

package/commands/computer.js

@@ -6,6 +6,7 @@
  *   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
@@ -24,6 +25,7 @@ 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();
@@ -150,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);
@@ -506,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++;
@@ -541,6 +599,8 @@ function parseComputerOptions(argv) {
     options: {
       worker: worker || null,
       model: model || null,
+      businessSlug: businessSlug ? String(businessSlug).trim() : null,
+      workspaceId: workspaceId ? String(workspaceId).trim() : null,
     },
   };
 }
@@ -575,6 +635,29 @@ function parseComputerCreateArgs(argv = []) {
   };
 }
 
+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}`];
@@ -954,9 +1037,33 @@ 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 });
   if (list.ok) {
@@ -984,6 +1091,21 @@ 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) {
@@ -1054,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)}`,
@@ -1217,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;
     }
   }
@@ -1287,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;
   }
 
@@ -1302,10 +1463,14 @@ 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 = []) {
+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('');
@@ -1373,6 +1538,7 @@ async function computerCreate(token, args = []) {
     ? '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('');
@@ -1383,9 +1549,20 @@ async function computerCreate(token, args = []) {
   if (endpoint) console.log(`  Endpoint:  ${endpoint}`);
   console.log(`  Dashboard: ${appBase}/dashboard/gm/${ctx.businessId}`);
   console.log('');
-  console.log('Next:');
-  console.log(`  atris pull ${ctx.slug || ctx.businessId}`);
-  console.log('  atris computer');
+  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) {
@@ -1401,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;
   }
 
@@ -1415,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) {
@@ -2105,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}`);
@@ -2616,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 = '';
@@ -2632,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');
@@ -2669,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);
@@ -2695,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;
@@ -2706,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;
   }
@@ -2760,20 +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 a business computer');
+    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');
@@ -2787,8 +3106,11 @@ async function runComputer() {
     console.log('Examples:');
     console.log('  atris computer');
     console.log('  atris computer card --write');
-    console.log('  atris computer create "My Business Computer" --business atris-labs');
-    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');
@@ -2809,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');
@@ -2869,11 +3195,13 @@ async function runComputer() {
   switch (sub) {
     case 'chat': return computerChat(token, ctx, cloudOptions);
     case 'card': return computerCard(args.slice(1));
-    case 'create': return computerCreate(token, 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);
@@ -2897,4 +3225,6 @@ module.exports = {
   buildComputerCard,
   renderComputerCard,
   renderComputerCardMarkdown,
+  extractAttachedWorkspaceMismatch,
+  contextForAttachedWorkspaceMismatch,
 };

package/commands/gm.js

@@ -5,7 +5,7 @@ const os = require('os');
 const path = require('path');
 
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
-const AGENTXP_GLOBAL_SYNC_RULE = 'Use the owner-provided sync token first; fallback is atris login before sync.';
+const AGENTXP_GLOBAL_SYNC_RULE = 'Run atris login, then sync. Owner-provided sync tokens are guided-demo fallback only.';
 
 const ROLE_PLAYERS_TO_IGNORE = new Set([
   'game-manager',
@@ -266,9 +266,9 @@ function compactTask(task) {
 
 function globalSyncCommands(player) {
   return [
-    `atris xp sync --local --as ${player} --token <owner-provided-token>`,
     'atris login',
-    `atris xp sync --local --as ${player}`,
+    'atris xp sync --local',
+    'atris xp sync --local --token <owner-provided-token>',
   ];
 }
 
@@ -367,7 +367,7 @@ function render(state) {
 
   console.log('');
   console.log('XP rule: no proof, no AgentXP; accept/revise stays human-gated.');
-  console.log('Global sync: use owner token first; fallback to atris login before hosted leaderboard sync.');
+  console.log('Global sync: run atris login, then sync; owner tokens are guided-demo fallback only.');
   console.log(`Leaderboard: ${state.leaderboard_url}`);
   console.log('');
   console.log('Next commands:');