atris 3.15.31 → 3.15.36

package/commands/lifecycle.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses, businessMatchesSlug } = require('./business');
 
 /**
  * Resolve business slug from CLI arg or local .atris/business.json.
@@ -22,6 +23,69 @@ function resolveSlug() {
   return slug;
 }
 
+async function resolveBusiness(token, slug) {
+  const businesses = loadBusinesses();
+
+  const listResult = await apiRequestJson('/business/', { method: 'GET', token });
+  if (listResult.ok && Array.isArray(listResult.data)) {
+    const match = listResult.data.find((business) =>
+      businessMatchesSlug(business, slug, { includeName: true })
+    );
+    if (match && match.id) {
+      businesses[slug] = {
+        business_id: match.id,
+        workspace_id: match.workspace_id,
+        name: match.name || slug,
+        slug: match.slug || slug,
+        canonical_slug: match.slug || slug,
+        added_at: businesses[slug]?.added_at || new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+      saveBusinesses(businesses);
+      return businesses[slug];
+    }
+  }
+
+  const wanted = String(slug || '').toLowerCase();
+  return businesses[slug] || Object.values(businesses).find((entry) =>
+    entry
+      && (
+        String(entry.slug || '').toLowerCase() === wanted
+        || String(entry.canonical_slug || '').toLowerCase() === wanted
+        || String(entry.name || '').toLowerCase() === wanted
+      )
+  ) || null;
+}
+
+async function activateBusinessWorkspace(token, business) {
+  if (!business?.business_id || !business?.workspace_id) return;
+  const result = await apiRequestJson(`/business/${business.business_id}/workspaces/${business.workspace_id}/activate`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!result.ok && result.status !== 409) {
+    throw new Error(`Failed to activate business workspace: ${result.errorMessage || result.error || result.status}`);
+  }
+}
+
+async function waitForBusinessComputer(token, business, maxWait = 90000) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    await new Promise((r) => setTimeout(r, 3000));
+
+    const status = await apiRequestJson(`/business/${business.business_id}/ai-computer/status`, {
+      method: 'GET',
+      token,
+    });
+
+    if (status.ok && status.data && status.data.status === 'running' && status.data.endpoint) {
+      return status.data;
+    }
+  }
+  return null;
+}
+
 /**
  * Pause a workspace to save compute (storage only mode).
  * @returns {Promise<void>}
@@ -39,6 +103,23 @@ async function sleepAtris() {
   const creds = loadCredentials();
   if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
 
+  const business = await resolveBusiness(creds.token, slug);
+  if (business?.business_id) {
+    const result = await apiRequestJson(`/business/${business.business_id}/ai-computer/sleep`, {
+      method: 'POST',
+      token: creds.token,
+      body: {},
+    });
+
+    if (!result.ok) {
+      console.error(`Failed to sleep business computer: ${result.error || result.errorMessage || result.status}`);
+      process.exit(1);
+    }
+
+    console.log(`Business computer '${business.name || slug}' is now sleeping. Files persist. Wake it with: atris wake ${slug}`);
+    return;
+  }
+
   const result = await apiRequestJson(`/workspace/${slug}/sleep`, {
     method: 'POST',
     token: creds.token,
@@ -70,6 +151,40 @@ async function wakeAtris() {
   const creds = loadCredentials();
   if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
 
+  const business = await resolveBusiness(creds.token, slug);
+  if (business?.business_id) {
+    if (business.workspace_id) {
+      await activateBusinessWorkspace(creds.token, business);
+    }
+
+    const result = await apiRequestJson(`/business/${business.business_id}/ai-computer/wake`, {
+      method: 'POST',
+      token: creds.token,
+      body: {},
+    });
+
+    if (!result.ok) {
+      console.error(`Failed to wake business computer: ${result.error || result.errorMessage || result.status}`);
+      process.exit(1);
+    }
+
+    console.log(`Waking business computer '${business.name || slug}'...`);
+
+    if (result.data && result.data.status === 'running' && result.data.endpoint) {
+      console.log(`Business computer '${business.name || slug}' is alive. Agents resuming.`);
+      return;
+    }
+
+    const running = await waitForBusinessComputer(creds.token, business);
+    if (running) {
+      console.log(`Business computer '${business.name || slug}' is alive. Agents resuming.`);
+      return;
+    }
+
+    console.log('Still starting up. Check with: atris computer status --business ' + slug);
+    return;
+  }
+
   const result = await apiRequestJson(`/workspace/${slug}/wake`, {
     method: 'POST',
     token: creds.token,

package/commands/mission.js

@@ -707,7 +707,8 @@ function worktreeReceipt(before, after, { verifier = '' } = {}) {
 // ---------------------------------------------------------------------------
 // `atris mission run <id>` — bounded local headless loop. v0.1.
 // Spawns `claude -p --resume <session>` per tick. Honors cadence, active-hours,
-// rate-limit info, and a flock per mission. Only consumes max-ticks on `ran`.
+// rate-limit info, and a flock per mission. `max-ticks` bounds total attempts;
+// `ran_ticks` separately reports ticks that actually made progress.
 // ---------------------------------------------------------------------------
 
 const MISSION_RUN_DEFAULTS = {
@@ -1284,7 +1285,7 @@ async function runMission(args) {
     const sessionLabel = skipWorker ? 'caller-session' : (sessionId || `pending=${pendingSessionId}`);
     console.error(`[mission run] ${mission.id}\n  objective: ${mission.objective}\n  lane: ${frozen.lane}\n  cadence: ${cadence} (${cadenceSeconds}s)\n  max_ticks: ${effectiveMaxTicks}, max_wall: ${maxWallSeconds}s\n  session: ${sessionLabel}`);
 
-    while (ranTicks < effectiveMaxTicks) {
+    while (ticks.length < effectiveMaxTicks) {
       const elapsedSec = (Date.now() - startedAt) / 1000;
       const remainingWall = maxWallSeconds - elapsedSec;
       if (remainingWall <= 0) { pauseReason = 'max-wall-reached'; break; }
@@ -1462,12 +1463,17 @@ async function runMission(args) {
       }
       const remainingMs = remainingWall * 1000 - 1;
       sleepMs = Math.min(Math.max(0, sleepMs), Math.max(0, remainingMs));
-      if (sleepMs > 0 && ranTicks < effectiveMaxTicks) {
+      if (sleepMs > 0 && ticks.length < effectiveMaxTicks) {
         try { await sleep(sleepMs, controller.signal); }
         catch (e) { if (e.code === 'ABORTED') { pauseReason = 'aborted'; break; } throw e; }
       }
     }
 
+    if (!pauseReason && ticks.length >= effectiveMaxTicks) {
+      const lastTick = ticks[ticks.length - 1];
+      if (lastTick && lastTick.status !== 'ran') pauseReason = 'max-ticks-reached';
+    }
+
     if (pauseReason && !['complete', 'ready', 'max-wall-reached'].includes(pauseReason)) {
       mission = saveMission({
         ...mission,

package/commands/play.js

@@ -7,7 +7,7 @@ const { spawnSync } = require('child_process');
 const { getSessionProfile, loadCredentials } = require('../utils/auth');
 
 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.';
 
 function showHelp() {
   console.log('');
@@ -257,9 +257,9 @@ function starterMissionPrompt(player) {
 
 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 --as ${player} --token <owner-provided-token>`,
   ];
 }
 
@@ -431,7 +431,7 @@ function render(state) {
   console.log('');
   console.log('Win condition: real artifact + verifier + human accept.');
   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:');

package/commands/xp.js

@@ -20,6 +20,50 @@ const AGENT_XP_LABEL = 'AgentXP';
 const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
 const LEVEL_XP = 1000;
 const RECEIPT_CHAIN_VERSION = 'atris.career_xp_receipt_chain.v1';
+const VALIDATION_TERMS = ['verify', 'verified', 'verifier', 'passed', 'pytest', 'receipt', 'score', 'smoke', 'git diff --check'];
+const QUALITY_TERMS = ['craft', 'scorecard', 'quality', 'critique', 'review', 'taste'];
+const ATRIS_ACCEPTED_STATUSES = new Set(['accepted', 'approved', 'done', 'review', 'reviewed', 'unknown']);
+const ATRIS_ACCEPTED_EVENTS = new Set(['accepted', 'approved', 'completed', 'done', 'reviewed', 'unknown']);
+const EARNING_MODEL = {
+  schema: 'atris.agentxp_earning_model.v1',
+  score_name: AGENT_XP_LABEL,
+  primary_public_source: 'accepted_task_receipt',
+  public_rule: 'No accepted proof-backed task episodes means no AgentXP leaderboard movement.',
+  weights: [
+    {
+      id: 'accepted_task_receipt',
+      label: 'Accepted proof-backed task',
+      relative_weight: 1,
+      public_leaderboard: true,
+      rl_value: 'high',
+    },
+    {
+      id: 'validated_agent_loop',
+      label: 'Verifier or agent loop inside an accepted task',
+      relative_weight: 0.35,
+      public_leaderboard: true,
+      rl_value: 'high',
+    },
+    {
+      id: 'atris_action_signal',
+      label: 'Atris action signal',
+      relative_weight: 0.1,
+      public_leaderboard: false,
+      rl_value: 'medium',
+    },
+    {
+      id: 'local_assistant_activity',
+      label: 'Local assistant activity',
+      relative_weight: 0.05,
+      public_leaderboard: false,
+      rl_value: 'medium',
+    },
+  ],
+  caps: {
+    local_assistant_activity: 'Capped below 10% of accepted-task XP and never unlocks public ranking alone.',
+    atris_action_signal: 'Routes RL and next moves, but does not outrank an accepted proof-backed task.',
+  },
+};
 const XP_STATE_FILES = new Set([
   path.basename(TASK_EPISODES_FILE),
   path.basename(CAREER_XP_RECEIPTS_FILE),
@@ -421,6 +465,199 @@ function sqlString(value) {
   return `'${String(value).replace(/'/g, "''")}'`;
 }
 
+function existingSignal(label, filePath) {
+  if (!filePath) return null;
+  try {
+    const stat = fs.statSync(expandHome(filePath));
+    return {
+      label,
+      kind: stat.isDirectory() ? 'dir' : 'file',
+      size_bytes: stat.isFile() ? stat.size : null,
+      mtime: stat.mtime.toISOString(),
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+function localAssistantProviderSignals(workspace) {
+  const codexStatePath = process.env.CODEX_STATE_DB || CODEX_STATE_FILE;
+  const candidates = [
+    {
+      id: 'codex',
+      label: 'Codex',
+      signals: [
+        existingSignal('codex_state', codexStatePath),
+        existingSignal('codex_history', path.join(os.homedir(), '.codex', 'history.jsonl')),
+        existingSignal('codex_sessions', path.join(os.homedir(), '.codex', 'sessions')),
+      ],
+    },
+    {
+      id: 'claude',
+      label: 'Claude',
+      signals: [
+        existingSignal('claude_home', path.join(os.homedir(), '.claude')),
+        existingSignal('claude_config', path.join(os.homedir(), '.claude.json')),
+        existingSignal('workspace_claude', path.join(workspace, '.claude')),
+      ],
+    },
+    {
+      id: 'cursor',
+      label: 'Cursor',
+      signals: [
+        existingSignal('workspace_cursor', path.join(workspace, '.cursor')),
+        existingSignal('cursor_home', path.join(os.homedir(), '.cursor')),
+        existingSignal('cursor_app_support', path.join(os.homedir(), 'Library', 'Application Support', 'Cursor')),
+      ],
+    },
+    {
+      id: 'devin',
+      label: 'Devin',
+      signals: [
+        existingSignal('workspace_devin', path.join(workspace, '.devin')),
+        existingSignal('devin_home', path.join(os.homedir(), '.devin')),
+      ],
+    },
+  ];
+
+  return candidates.map((provider) => {
+    const signals = provider.signals.filter(Boolean);
+    return {
+      id: provider.id,
+      label: provider.label,
+      detected: signals.length > 0,
+      signal_count: signals.length,
+      signals,
+    };
+  });
+}
+
+function buildLocalAssistantActivity(workspace, acceptedTaskXp = 0) {
+  const providers = localAssistantProviderSignals(workspace);
+  const detected = providers.filter(provider => provider.detected);
+  const rawSignalCount = detected.reduce((sum, provider) => sum + provider.signal_count, 0);
+  const weight = EARNING_MODEL.weights.find(item => item.id === 'local_assistant_activity')?.relative_weight || 0.05;
+  const weightedContext = Math.round(rawSignalCount * weight * 100) / 100;
+  const acceptedXp = asNumber(acceptedTaskXp);
+  const contextCap = Math.round(acceptedXp * 0.1 * 100) / 100;
+  const contextAgentXp = acceptedXp > 0 ? Math.min(weightedContext, contextCap) : 0;
+
+  return {
+    schema: 'atris.agentxp_local_assistant_activity.v1',
+    public_leaderboard: false,
+    source_type: 'local_assistant_activity',
+    weight,
+    context_weight: weight,
+    cap: {
+      max_public_xp_ratio: 0.1,
+      requires_accepted_task_xp: true,
+    },
+    cap_ratio_to_accepted_task_xp: 0.1,
+    cap_agent_xp: contextCap,
+    accepted_task_agent_xp: acceptedXp,
+    detected_providers: detected.map(provider => provider.id).sort(),
+    provider_count: detected.length,
+    providers,
+    raw_signal_count: rawSignalCount,
+    weighted_context_score: weightedContext,
+    context_agent_xp: contextAgentXp,
+    included_in_total_agent_xp: false,
+    role: 'context_only',
+    note: 'Local assistant activity helps context and RL; accepted proof-backed tasks are the public AgentXP source.',
+  };
+}
+
+function safeSignalKey(value) {
+  const text = String(value || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+  const clean = [...text].filter(char => /[a-z0-9_-]/.test(char)).join('');
+  return clean.slice(0, 40) || 'unknown';
+}
+
+function hasAnyTerm(text, terms) {
+  const lower = String(text || '').toLowerCase();
+  return terms.some(term => lower.includes(term));
+}
+
+function incrementCount(counts, key) {
+  counts[key] = (counts[key] || 0) + 1;
+}
+
+function buildAtrisActionSignalFromRows(rows = []) {
+  const eventTypeCounts = {};
+  const statusCounts = {};
+  const actors = new Set();
+  const claimants = new Set();
+  let proofBackedEpisodeCount = 0;
+  let acceptedEpisodeCount = 0;
+  let validationReceiptCount = 0;
+  let qualityReceiptCount = 0;
+  let claimedEpisodeCount = 0;
+
+  for (const row of rows || []) {
+    const action = row?.action && typeof row.action === 'object' ? row.action : {};
+    const state = row?.state && typeof row.state === 'object' ? row.state : {};
+    const eventType = safeSignalKey(action.event_type || action.type || action.name);
+    const status = safeSignalKey(state.status);
+    incrementCount(eventTypeCounts, eventType);
+    incrementCount(statusCounts, status);
+
+    const actor = slugify(action.actor || '');
+    if (actor) actors.add(actor);
+    const claimant = slugify(state.claimed_by || state.assigned_to || '');
+    if (claimant) {
+      claimants.add(claimant);
+      claimedEpisodeCount += 1;
+    }
+
+    const proof = String(row?.proof || '').trim();
+    const proofBacked = proof.length >= 20;
+    if (proofBacked) proofBackedEpisodeCount += 1;
+    if (proofBacked && hasAnyTerm(proof, VALIDATION_TERMS)) validationReceiptCount += 1;
+    if (proofBacked && hasAnyTerm(proof, QUALITY_TERMS)) qualityReceiptCount += 1;
+    if (
+      proofBacked
+      && status !== 'failed'
+      && (ATRIS_ACCEPTED_STATUSES.has(status) || ATRIS_ACCEPTED_EVENTS.has(eventType))
+    ) {
+      acceptedEpisodeCount += 1;
+    }
+  }
+
+  return {
+    schema: 'atris.agentxp_atris_action_signal.v1',
+    source: '.atris/state/task_episodes.jsonl',
+    episode_count: rows.length,
+    accepted_episode_count: acceptedEpisodeCount,
+    proof_backed_episode_count: proofBackedEpisodeCount,
+    validation_receipt_count: validationReceiptCount,
+    quality_receipt_count: qualityReceiptCount,
+    claimed_episode_count: claimedEpisodeCount,
+    reviewed_episode_count: eventTypeCounts.reviewed || 0,
+    distinct_actor_count: actors.size,
+    distinct_claimant_count: claimants.size,
+    event_type_counts: Object.fromEntries(Object.entries(eventTypeCounts).sort()),
+    status_counts: Object.fromEntries(Object.entries(statusCounts).sort()),
+    included_in_total_agent_xp: false,
+    public_leaderboard: false,
+    role: 'rl_routing_only',
+  };
+}
+
+function readTaskEpisodesForWorkspace(workspace) {
+  if (!workspace) return [];
+  return readJsonl(path.join(workspace, TASK_EPISODES_FILE));
+}
+
+function buildAtrisActionSignal(projection) {
+  const workspaceRoots = Array.isArray(projection?.workspaces)
+    ? projection.workspaces
+      .filter(workspace => workspace?.included && workspace.workspace_root)
+      .map(workspace => workspace.workspace_root)
+    : [projection?.workspace_root].filter(Boolean);
+  const rows = workspaceRoots.flatMap(workspace => readTaskEpisodesForWorkspace(workspace));
+  return buildAtrisActionSignalFromRows(rows);
+}
+
 function runSqliteJsonOptional(dbPath, sql) {
   if (!dbPath || !fs.existsSync(dbPath)) return [];
   const result = spawnSync('sqlite3', ['-readonly', '-json', dbPath, sql], { encoding: 'utf8' });
@@ -682,6 +919,7 @@ function buildCareerXpProjection(receipts, workspace, integrity = {}) {
     percent: Math.round((currentLevelXp / LEVEL_XP) * 1000) / 10,
   };
   const latest = latestReceipt(accepted);
+  const localActivity = buildLocalAssistantActivity(workspace, totalXp);
 
   return {
     schema: 'atris.career_xp_projection.v1',
@@ -707,6 +945,8 @@ function buildCareerXpProjection(receipts, workspace, integrity = {}) {
     contribution_graph: buildAgentXpContributionGraph(accepted),
     receipts_count: accepted.length,
     sources: countBySource(accepted),
+    earning_model: EARNING_MODEL,
+    local_activity: localActivity,
     latest_accepted_proof: latest ? {
       label: receiptLabel(latest),
       receipt_id: latest.receipt_id,
@@ -929,6 +1169,7 @@ function buildAllCareerXpProjection(projections, searchRoots = []) {
       integrity_status: projection?.integrity_status || projection?.integrity?.status || 'unknown',
       leaderboard_eligible: Boolean(projection?.leaderboard_eligible),
       latest_accepted_proof: projection?.latest_accepted_proof || null,
+      local_activity: projection?.local_activity || null,
       ledger: projection?.ledger || null,
     };
   }).sort((a, b) => {
@@ -960,6 +1201,17 @@ function buildAllCareerXpProjection(projections, searchRoots = []) {
   const contributionGraph = combineAgentXpContributionGraphs(
     verified.map(projection => projection.contribution_graph),
   );
+  const activityProviders = new Set();
+  let rawActivitySignals = 0;
+  let contextAgentXp = 0;
+  for (const projection of verified) {
+    const activity = projection.local_activity || {};
+    rawActivitySignals += asNumber(activity.raw_signal_count);
+    contextAgentXp += asNumber(activity.context_agent_xp);
+    for (const provider of activity.detected_providers || []) {
+      activityProviders.add(provider);
+    }
+  }
 
   return {
     schema: 'atris.career_xp_profile.v1',
@@ -985,8 +1237,19 @@ function buildAllCareerXpProjection(projections, searchRoots = []) {
     },
     contribution_graph: contributionGraph,
     receipts_count: verified.reduce((sum, projection) => sum + asNumber(projection.receipts_count), 0),
+    earning_model: EARNING_MODEL,
+    local_activity: {
+      schema: 'atris.agentxp_local_activity_summary.v1',
+      public_leaderboard: false,
+      detected_providers: Array.from(activityProviders).sort(),
+      raw_signal_count: rawActivitySignals,
+      context_agent_xp: Math.round(contextAgentXp * 100) / 100,
+      included_in_total_agent_xp: false,
+      note: 'Aggregated local assistant activity is context only; verified receipts define total AgentXP.',
+    },
     latest_accepted_proof: latest,
     workspaces,
+    integrity_status: warnings.length ? 'warnings' : 'verified',
     integrity: {
       status: warnings.length ? 'warnings' : 'verified',
       warnings,
@@ -1408,6 +1671,13 @@ function renderContributionGraph(graph) {
   console.log('Legend: blank none | . started | : solid | * heavy | # breakout');
 }
 
+function renderLocalActivity(activity) {
+  if (!activity || !Array.isArray(activity.detected_providers) || !activity.detected_providers.length) return;
+  console.log(
+    `Local activity: ${activity.detected_providers.join(', ')} | context ${formatNumber(activity.context_agent_xp)} | not public ${AGENT_XP_LABEL}`
+  );
+}
+
 function loadLocalPayload(args) {
   const workspace = path.resolve(readFlag(args, '--workspace', process.cwd()));
   const operator = readFlag(
@@ -1532,11 +1802,28 @@ function buildAgentXpSyncPacket(args = []) {
       trust_rule: 'Only verified local ledgers are uploaded; raw proof and paths stay local.',
     },
     local_evidence: {
+      schema: 'atris.agentxp_local_evidence.v1',
+      workspace_root_hash: workspaceRootHash,
       workspaces,
       verified_workspace_count: asNumber(projection.verified_workspace_count, verifiedProjection(projection) ? 1 : 0),
       receipts_count: receiptsCount,
       integrity_status: projection.integrity?.status || projection.integrity_status || 'unknown',
       ledger_head_hash: projection.integrity?.head_hash || null,
+      local_activity: {
+        schema: projection.local_activity?.schema || 'atris.agentxp_local_assistant_activity.v1',
+        detected_providers: projection.local_activity?.detected_providers || [],
+        provider_count: asNumber(projection.local_activity?.provider_count, (projection.local_activity?.detected_providers || []).length),
+        raw_signal_count: asNumber(projection.local_activity?.raw_signal_count),
+        context_agent_xp: asNumber(projection.local_activity?.context_agent_xp),
+        context_weight: asNumber(projection.local_activity?.context_weight, 0.05),
+        cap_ratio_to_accepted_task_xp: asNumber(projection.local_activity?.cap_ratio_to_accepted_task_xp, 0.1),
+        cap_agent_xp: asNumber(projection.local_activity?.cap_agent_xp),
+        accepted_task_agent_xp: asNumber(projection.local_activity?.accepted_task_agent_xp, totalXp),
+        included_in_total_agent_xp: false,
+        public_leaderboard: false,
+        role: 'context_only',
+      },
+      atris_actions: buildAtrisActionSignal(projection),
     },
     gm_projection: {
       schema: 'atris.gm_xp_projection.v1',
@@ -1583,7 +1870,10 @@ async function syncAgentXp(args = []) {
   } else {
     const ensured = await ensureValidCredentials(apiRequestJson);
     if (ensured.error) {
-      throw new Error(`Missing sync auth. Run atris login, or set ATRIS_AGENTXP_SYNC_TOKEN${ensured.detail ? ` (${ensured.detail})` : ''}.`);
+      throw new Error(
+        `Missing sync auth. Run atris login, then retry atris xp sync. `
+        + `Guided demos can pass --token <owner-provided-token>${ensured.detail ? ` (${ensured.detail})` : ''}.`
+      );
     }
     options.token = ensured.credentials.token;
   }
@@ -1609,7 +1899,8 @@ function renderSync(payload) {
   console.log(`Player ${payload.player || entry.username || 'player'} | AgentXP ${formatNumber(entry.agent_xp)} | receipts ${formatNumber(entry.verified_receipts)}`);
   if (payload.dry_run) {
     console.log(`Packet ${payload.packet?.packet_hash || 'unhashed'} ready; no network upload ran.`);
-    console.log('Run with ATRIS_AGENTXP_SYNC_TOKEN set to publish to the hosted leaderboard.');
+    console.log(`Run atris login, then atris xp sync --local --as ${payload.player || entry.username || '<player>'} to publish to the hosted leaderboard.`);
+    console.log('Guided demos can pass --token <owner-provided-token>.');
     console.log(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
     return;
   }
@@ -1673,6 +1964,7 @@ function render(payload) {
     } else {
       console.log('Latest proof: none accepted yet');
     }
+    renderLocalActivity(payload.local_activity);
     const integrity = payload.integrity || {};
     console.log(`Integrity: ${integrity.status || 'unknown'} (${integrity.local_trust || 'local'})`);
     for (const warning of integrity.warnings || []) {
@@ -1694,6 +1986,7 @@ function render(payload) {
     } else {
       console.log('Latest proof: none accepted yet');
     }
+    renderLocalActivity(payload.local_activity);
     console.log(`Ledger: ${payload.ledger?.projection_path || CAREER_XP_PROJECTION_FILE}`);
     return;
   }