atris 3.30.12 → 3.32.0

package/commands/autopilot.js

@@ -15,7 +15,7 @@ const { parseTodo } = require('../lib/todo');
 const {
   buildRunnerCommand,
   buildRunnerAvailabilityCommand,
-  resolveClaudeRunnerBin,
+  runnerAvailabilityFailureMessage,
 } = require('../lib/runner-command');
 const { findStalePages, findStaleTasks, healBrokenMapRefs } = require('./clean');
 const {
@@ -484,6 +484,91 @@ function executePhaseDetailed(phase, context, options = {}) {
   }
 }
 
+function autopilotGlassLogDir(cwd = process.cwd()) {
+  const dir = path.join(cwd, 'atris', 'logs', 'autopilot');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function autopilotGlassSlug(value) {
+  const slug = String(value || 'tick')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+  return slug || 'tick';
+}
+
+function autopilotGlassTimestamp(now = new Date()) {
+  return now.toISOString().replace(/[:.]/g, '-');
+}
+
+function phaseGlassText(phaseResults, key) {
+  const phase = phaseResults && phaseResults[key] ? phaseResults[key] : {};
+  const output = String(phase.output || '').trim();
+  const elapsed = Number.isFinite(phase.elapsedSeconds) ? `\n\nElapsed: ${phase.elapsedSeconds}s` : '';
+  return `${output || '(no output)'}${elapsed}`;
+}
+
+function buildAutopilotGlassLog(context, execution, options = {}) {
+  const phaseResults = execution.phaseResults || {};
+  const task = context.task || 'Autopilot tick';
+  const generatedAt = options.generatedAt || new Date().toISOString();
+  const proof = execution.verifyRan
+    ? `${execution.verifyPass ? 'PASS' : 'FAIL'}: ${phaseGlassText(phaseResults, 'verify')}`
+    : 'NOT RUN: no verifier command was available';
+
+  return [
+    '# Autopilot Glass Log',
+    '',
+    `Generated: ${generatedAt}`,
+    `Task: ${task}`,
+    `Kind: ${context.kind || 'unknown'}`,
+    `Verify: ${execution.verifyCmd || '(none)'}`,
+    `Outcome: ${execution.success ? 'success' : 'needs attention'}`,
+    '',
+    '## Plan',
+    '',
+    phaseGlassText(phaseResults, 'plan'),
+    '',
+    '## Plan Review',
+    '',
+    phaseGlassText(phaseResults, 'plan-review'),
+    '',
+    '## Action',
+    '',
+    phaseGlassText(phaseResults, 'do'),
+    '',
+    '## Result',
+    '',
+    phaseGlassText(phaseResults, 'review'),
+    '',
+    '## Proof',
+    '',
+    proof,
+    ''
+  ].join('\n');
+}
+
+function writeAutopilotGlassLog(cwd, context, execution, options = {}) {
+  const dir = autopilotGlassLogDir(cwd);
+  const now = options.now || new Date();
+  const file = `${autopilotGlassTimestamp(now)}-${autopilotGlassSlug(context.task)}.md`;
+  const absPath = path.join(dir, file);
+  fs.writeFileSync(absPath, buildAutopilotGlassLog(context, execution, {
+    generatedAt: now.toISOString(),
+  }));
+  return path.relative(cwd, absPath);
+}
+
+function maybeWriteAutopilotGlassLog(cwd, context, execution) {
+  try {
+    return writeAutopilotGlassLog(cwd, context, execution);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Build context-aware file list for prompts.
  */
@@ -1806,7 +1891,7 @@ function runTaskOnce(context, options = {}) {
     }
   }
 
-  return {
+  const execution = {
     success: verifyRan && verifyPass,
     elapsedSeconds: Math.round((Date.now() - startedAt) / 1000),
     phaseResults,
@@ -1815,6 +1900,8 @@ function runTaskOnce(context, options = {}) {
     verifyPass,
     verifyRan,
   };
+  execution.glassLogPath = maybeWriteAutopilotGlassLog(cwd, context, execution);
+  return execution;
 }
 
 /**
@@ -3022,8 +3109,8 @@ async function autopilotAtris(description, options = {}) {
     process.exit(1);
   }
 
-  try { execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' }); } catch {
-    console.error(`${resolveClaudeRunnerBin()} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`);
+  try { execSync(buildRunnerAvailabilityCommand(), { stdio: 'pipe' }); } catch (err) {
+    console.error(runnerAvailabilityFailureMessage(err));
     process.exit(1);
   }
 
@@ -3679,5 +3766,8 @@ module.exports = {
   isPhaseKillError,
   execPhaseCommandSync,
   executePhaseDetailed,
+  autopilotGlassLogDir,
+  buildAutopilotGlassLog,
+  writeAutopilotGlassLog,
   lessonSlug
 };

package/commands/business.js

@@ -840,7 +840,7 @@ function renderBusinessOsLines(os = {}, prefix = '- ') {
     `${prefix}Team goals: ${team.members || 0} member lanes, ${team.activeGoalMembers || 0} with active goals`,
     `${prefix}${xp.metric || 'AgentXP'}: ${xp.total || 0} total, ${xp.today || 0} today, ${xp.receipts || 0} receipts, integrity ${xp.integrity || 'unknown'}`,
     `${prefix}Loop: ${loop.ticks || 0} mission ticks; Codex goal ${loop.codexGoal || 'none'}`,
-    `${prefix}XP gate: proof can move to Review; XP lands only after human accept`,
+    `${prefix}XP gate: proof can move to Review; XP is awarded only after human approval`,
   ];
 }
 

package/commands/clean.js

@@ -15,20 +15,23 @@ function cleanAtris(options = {}) {
   const atrisDir = path.join(cwd, 'atris');
 
   if (!fs.existsSync(atrisDir)) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        ok: false,
+        action: 'clean',
+        error: 'atris/ folder not found. Run "atris init" first.',
+      }, null, 2));
+      process.exit(1);
+    }
     console.log('✗ atris/ folder not found. Run "atris init" first.');
     process.exit(1);
   }
 
-  console.log('');
-  console.log('┌─────────────────────────────────────────────────────────────┐');
-  console.log('│ Atris Clean                                                 │');
-  console.log('└─────────────────────────────────────────────────────────────┘');
-  console.log('');
-
   const results = {
     staleTasks: [],
     brokenRefs: [],
     healedRefs: 0,
+    healedRefDetails: [],
     unhealableRefs: [],
     archivedJournals: 0,
     cleanedSections: 0
@@ -39,8 +42,9 @@ function cleanAtris(options = {}) {
   results.staleTasks = staleTasks;
 
   // 2. Find and HEAL broken MAP.md references
-  const { healed, unhealable } = healBrokenMapRefs(cwd, atrisDir, options.dryRun);
+  const { healed, unhealable, replacements } = healBrokenMapRefs(cwd, atrisDir, options.dryRun);
   results.healedRefs = healed;
+  results.healedRefDetails = replacements;
   results.unhealableRefs = unhealable;
 
   // 3. Archive old journals (>30 days)
@@ -55,6 +59,17 @@ function cleanAtris(options = {}) {
   const stalePages = findStalePages(cwd, atrisDir);
   results.stalePages = stalePages;
 
+  if (options.json) {
+    console.log(JSON.stringify(cleanResultPayload(results, options, cwd), null, 2));
+    return results;
+  }
+
+  console.log('');
+  console.log('┌─────────────────────────────────────────────────────────────┐');
+  console.log('│ Atris Clean                                                 │');
+  console.log('└─────────────────────────────────────────────────────────────┘');
+  console.log('');
+
   // Report results
   console.log('Results:');
   console.log('');
@@ -74,6 +89,12 @@ function cleanAtris(options = {}) {
   if (healed > 0) {
     const verb = options.dryRun ? 'Would heal' : 'Healed';
     console.log(`✓ ${verb} ${healed} MAP.md ${healed === 1 ? 'reference' : 'references'}`);
+    (results.healedRefDetails || []).slice(0, 3).forEach(ref => {
+      console.log(`   • ${ref.old} -> ${ref.new}${ref.symbol ? ` (${ref.symbol})` : ''}`);
+    });
+    if ((results.healedRefDetails || []).length > 3) {
+      console.log(`   ... and ${results.healedRefDetails.length - 3} more`);
+    }
   }
 
   // Unhealable refs
@@ -138,6 +159,47 @@ function cleanAtris(options = {}) {
   return results;
 }
 
+function cleanResultPayload(results, options = {}, cwd = process.cwd()) {
+  const manualAction = [];
+  if (results.staleTasks.length > 0) manualAction.push('Delete stale tasks or finish them');
+  if (results.unhealableRefs.length > 0) manualAction.push('Manually fix unhealable MAP.md refs');
+  if (results.stalePages.length > 0) manualAction.push('Re-compile stale pages');
+  return {
+    ok: manualAction.length === 0,
+    action: 'clean',
+    dry_run: !!options.dryRun,
+    results: {
+      stale_tasks: {
+        count: results.staleTasks.length,
+        items: results.staleTasks,
+      },
+      map_refs: {
+        healed_count: results.healedRefs,
+        verb: options.dryRun ? 'would_heal' : 'healed',
+        items: results.healedRefDetails || [],
+        unhealable_count: results.unhealableRefs.length,
+        unhealable: results.unhealableRefs,
+      },
+      journals: {
+        archived_count: results.archivedJournals,
+        verb: options.dryRun ? 'would_archive' : 'archived',
+      },
+      sections: {
+        cleaned_count: results.cleanedSections,
+        verb: options.dryRun ? 'would_clean' : 'cleaned',
+      },
+      stale_pages: {
+        count: results.stalePages.length,
+        items: results.stalePages.map(page => ({
+          page: path.relative(cwd, page.page),
+          stale_source: page.staleSource,
+        })),
+      },
+    },
+    manual_action: manualAction,
+  };
+}
+
 /**
  * Find tasks claimed but not completed after 3+ days
  */
@@ -295,7 +357,7 @@ function healBrokenMapRefs(cwd, atrisDir, dryRun = false) {
     fs.writeFileSync(mapFile, mapContent);
   }
 
-  return { healed, unhealable, replacements: dryRun ? replacements : [] };
+  return { healed, unhealable, replacements };
 }
 
 /**
@@ -337,7 +399,7 @@ function findFunctionEnd(lines, startLine) {
 }
 
 /**
- * Extract a symbol name from context like "(atrisDevEntry function)" or "— Main entry"
+ * Extract a symbol name from context like "(interactiveEntry function)" or "— Main entry"
  */
 function extractSymbol(context) {
   if (!context) return null;
@@ -568,6 +630,7 @@ function cleanEmptySections(atrisDir, dryRun = false) {
 
 module.exports = {
   cleanAtris,
+  cleanResultPayload,
   findStaleTasks,
   healBrokenMapRefs,
   archiveOldJournals,

package/commands/codex-goal.js

@@ -32,7 +32,50 @@ function sqlString(value) {
 }
 
 function resolveStatePath(args = []) {
-  return path.resolve(expandHome(readFlag(args, '--state', process.env.CODEX_STATE_DB || path.join(os.homedir(), '.codex', 'state_5.sqlite'))));
+  const explicit = readFlag(args, '--state', process.env.CODEX_STATE_DB || '');
+  if (explicit) return path.resolve(expandHome(explicit));
+  // Codex moved native goals into ~/.codex/goals_1.sqlite; older builds kept them in state_5.sqlite.
+  // Prefer the live goals DB so the bridge sees real goal activity, fall back to the legacy state DB.
+  const goalsDb = path.join(os.homedir(), '.codex', 'goals_1.sqlite');
+  const legacyDb = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+  return path.resolve(fs.existsSync(goalsDb) ? goalsDb : legacyDb);
+}
+
+// Thread metadata (cwd/title) stayed in state_5.sqlite even after goals moved to goals_1.sqlite.
+function resolveThreadsPath(args = []) {
+  const explicit = readFlag(args, '--threads-db', process.env.CODEX_THREADS_DB || '');
+  if (explicit) return path.resolve(expandHome(explicit));
+  const legacyDb = path.join(os.homedir(), '.codex', 'state_5.sqlite');
+  return fs.existsSync(legacyDb) ? path.resolve(legacyDb) : '';
+}
+
+function tableExists(dbPath, table) {
+  if (!dbPath || !fs.existsSync(dbPath)) return false;
+  try {
+    const rows = runSqliteJson(dbPath, `SELECT name FROM sqlite_master WHERE type='table' AND name=${sqlString(table)} LIMIT 1;`);
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Goals live in goals_1.sqlite (no `threads` table); thread metadata lives in state_5.sqlite.
+// Legacy single-file layouts (and test fixtures) keep both in one DB. Resolve which join to use.
+function goalQueryContext(args = []) {
+  const goalsDb = resolveStatePath(args);
+  if (tableExists(goalsDb, 'threads')) {
+    return { goalsDb, threadsTable: 'threads', prefix: '' };
+  }
+  const threadsDb = resolveThreadsPath(args);
+  if (threadsDb && threadsDb !== goalsDb && tableExists(threadsDb, 'threads')) {
+    return { goalsDb, threadsTable: 'tdb.threads', prefix: `ATTACH ${sqlString(threadsDb)} AS tdb;\n` };
+  }
+  return { goalsDb, threadsTable: null, prefix: '' };
+}
+
+function runGoalQuery(args, buildSql) {
+  const ctx = goalQueryContext(args);
+  return runSqliteJson(ctx.goalsDb, ctx.prefix + buildSql(ctx.threadsTable));
 }
 
 function defaultRunsDir(args = []) {
@@ -81,7 +124,11 @@ function ensureStateDb(dbPath) {
   }
 }
 
-function selectGoalSql(whereClause, limit = 10) {
+function selectGoalSql(whereClause, limit = 10, threadsTable = 'threads') {
+  const join = threadsTable ? `LEFT JOIN ${threadsTable} t ON t.id = tg.thread_id` : '';
+  const cwd = threadsTable ? 't.cwd' : 'NULL';
+  const title = threadsTable ? 't.title' : 'NULL';
+  const threadUpdated = threadsTable ? 't.updated_at_ms' : 'NULL';
   return `
 SELECT
   tg.thread_id,
@@ -93,41 +140,43 @@ SELECT
   tg.time_used_seconds,
   tg.created_at_ms,
   tg.updated_at_ms,
-  t.cwd AS thread_cwd,
-  t.title AS thread_title,
-  t.updated_at_ms AS thread_updated_at_ms
+  ${cwd} AS thread_cwd,
+  ${title} AS thread_title,
+  ${threadUpdated} AS thread_updated_at_ms
 FROM thread_goals tg
-LEFT JOIN threads t ON t.id = tg.thread_id
+${join}
 ${whereClause}
-ORDER BY COALESCE(t.updated_at_ms, tg.updated_at_ms) DESC
+ORDER BY COALESCE(${threadUpdated}, tg.updated_at_ms) DESC
 LIMIT ${Number(limit) || 10}
 `;
 }
 
-function readGoalByThread(dbPath, threadId) {
-  const rows = runSqliteJson(dbPath, selectGoalSql(`WHERE tg.thread_id = ${sqlString(threadId)}`, 1));
+function readGoalByThread(args, threadId) {
+  const rows = runGoalQuery(args, (tt) => selectGoalSql(`WHERE tg.thread_id = ${sqlString(threadId)}`, 1, tt));
   return rows[0] || null;
 }
 
-function readLatestGoalForCwd(dbPath, cwd) {
+function readLatestGoalForCwd(args, cwd) {
+  const ctx = goalQueryContext(args);
+  if (!ctx.threadsTable) return null; // cannot cwd-match without thread metadata
   const realCwd = fs.realpathSync.native ? fs.realpathSync.native(cwd) : fs.realpathSync(cwd);
   const pwd = process.env.PWD || '';
   const pwdReal = pwd && fs.existsSync(pwd) ? (fs.realpathSync.native ? fs.realpathSync.native(pwd) : fs.realpathSync(pwd)) : '';
   const candidates = [...new Set([cwd, realCwd, pwdReal === realCwd ? pwd : ''].filter(Boolean))];
-  const rows = runSqliteJson(dbPath, selectGoalSql(`WHERE t.cwd IN (${candidates.map(sqlString).join(', ')})`, 1));
+  const rows = runSqliteJson(ctx.goalsDb, ctx.prefix + selectGoalSql(`WHERE t.cwd IN (${candidates.map(sqlString).join(', ')})`, 1, ctx.threadsTable));
   return rows[0] || null;
 }
 
-function readRecentGoals(dbPath, limit = 10) {
-  return runSqliteJson(dbPath, selectGoalSql('', limit));
+function readRecentGoals(args, limit = 10) {
+  return runGoalQuery(args, (tt) => selectGoalSql('', limit, tt));
 }
 
-function resolveThreadGoal(dbPath, args) {
+function resolveThreadGoal(args) {
   const explicitThread = readFlag(args, '--thread', '');
-  if (explicitThread) return readGoalByThread(dbPath, explicitThread);
-  if (hasFlag(args, '--latest')) return readLatestGoalForCwd(dbPath, process.cwd());
+  if (explicitThread) return readGoalByThread(args, explicitThread);
+  if (hasFlag(args, '--latest')) return readLatestGoalForCwd(args, process.cwd());
   const envThread = process.env.CODEX_THREAD_ID || '';
-  if (envThread) return readGoalByThread(dbPath, envThread);
+  if (envThread) return readGoalByThread(args, envThread);
   return null;
 }
 
@@ -163,7 +212,7 @@ function statusCommand(args) {
   const dbPath = resolveStatePath(args);
   ensureStateDb(dbPath);
 
-  const goal = resolveThreadGoal(dbPath, args);
+  const goal = resolveThreadGoal(args);
   if (goal) {
     const payload = { ok: true, schema: SCHEMA, action: 'status', state_path: dbPath, goal };
     printJsonOrText(payload, [
@@ -176,7 +225,7 @@ function statusCommand(args) {
   }
 
   const limit = Math.max(1, Math.min(50, Number(readFlag(args, '--limit', '10')) || 10));
-  const goals = readRecentGoals(dbPath, limit);
+  const goals = readRecentGoals(args, limit);
   const payload = { ok: true, schema: SCHEMA, action: 'status', state_path: dbPath, goals };
   printJsonOrText(payload, [
     `Codex goals: ${goals.length} recent`,
@@ -192,7 +241,7 @@ function resetCommand(args) {
   ensureStateDb(dbPath);
 
   const startedAt = new Date().toISOString();
-  const goal = resolveThreadGoal(dbPath, args);
+  const goal = resolveThreadGoal(args);
   if (!goal) {
     throw new Error('No Codex goal found. Pass --thread <thread-id> or --latest.');
   }
@@ -238,7 +287,7 @@ SELECT changes() AS deleted;
 COMMIT;
 `, { readonly: false });
   const deleted = Number(rows[0]?.deleted || 0);
-  const remaining = readGoalByThread(dbPath, goal.thread_id);
+  const remaining = readGoalByThread(args, goal.thread_id);
   const ok = deleted === 1 && !remaining;
   const payload = writeReceipt(outDir, {
     ok,
@@ -277,7 +326,8 @@ function usage() {
     `  atris codex-goal reset --thread <id> ${CONFIRM_RESET_FLAG}`,
     '',
     'Flags:',
-    '  --state <path>      Codex state DB (default ~/.codex/state_5.sqlite)',
+    '  --state <path>      Codex goals DB (default ~/.codex/goals_1.sqlite, falls back to state_5.sqlite)',
+    '  --threads-db <path> Codex thread metadata DB for cwd/title (default ~/.codex/state_5.sqlite)',
     '  --latest           Use the latest Codex goal whose thread cwd matches the current directory',
     '  --out-dir <path>   Receipt/backup directory (default .atris/runs)',
     '',

package/commands/computer.js

@@ -1635,6 +1635,41 @@ async function resolveBusinessContextBySlug(token, slug, options = {}) {
   return null;
 }
 
+function shortcutBusinessLabel(slug, fallbackName) {
+  if (normalizeBusinessSlug(slug) === RECRUITING_BUSINESS_SLUG) return 'Atris Labs';
+  return fallbackName || slug;
+}
+
+async function resolveSingleBusinessShortcutFallback(token, slug) {
+  const wantedSlug = normalizeBusinessSlug(slug);
+  if (wantedSlug !== RECRUITING_BUSINESS_SLUG) return null;
+
+  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  const rows = list.ok && Array.isArray(list.data)
+    ? list.data.filter((business) => business && business.id)
+    : [];
+  if (rows.length !== 1) return null;
+
+  const match = rows[0];
+  const businesses = loadBusinesses();
+  const businessName = shortcutBusinessLabel(wantedSlug, match.name || match.slug);
+  businesses[wantedSlug] = {
+    business_id: match.id,
+    workspace_id: match.workspace_id,
+    name: businessName,
+    slug: wantedSlug,
+    cloud_slug: match.slug || null,
+    added_at: new Date().toISOString(),
+  };
+  saveBusinesses(businesses);
+  return {
+    slug: wantedSlug,
+    businessId: match.id,
+    workspaceId: match.workspace_id,
+    businessName,
+  };
+}
+
 async function resolveComputerCommandContext(token, options = {}) {
   if (options.businessSlug || options.workspaceId) {
     const ctx = options.businessSlug
@@ -1660,7 +1695,10 @@ async function resolveTypedBusinessComputerContext(token, options = {}, defaults
     return resolveComputerCommandContext(token, { ...options, businessSlug });
   }
 
-  const ctx = await resolveBusinessContextBySlug(token, businessSlug, { preferCache: true });
+  let ctx = await resolveBusinessContextBySlug(token, businessSlug, { preferCache: true });
+  if (!ctx?.businessId && (options.allowCanonicalShortcutFallback || defaults.allowCanonicalShortcutFallback)) {
+    ctx = await resolveSingleBusinessShortcutFallback(token, businessSlug);
+  }
   if (!ctx?.businessId) return null;
   const workspaces = await listBusinessWorkspaces(token, ctx);
   const workspace = resolveWorkspaceByComputerType(workspaces, computerType);
@@ -1705,7 +1743,7 @@ async function resolveWorkspaceSelector(token, ctx, input) {
   return workspace?.id || selector;
 }
 
-async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
+async function resolveBusinessOwnerForCreate(token, businessSlug = null, options = {}) {
   const wantedSlug = businessSlug ? String(businessSlug).trim() : null;
   if (wantedSlug) {
     const fromApi = await resolveBusinessContextBySlug(token, wantedSlug);
@@ -1720,6 +1758,9 @@ async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
         businessName: cached.name || cached.slug || wantedSlug,
       };
     }
+    if (options.allowCanonicalShortcutFallback) {
+      return resolveSingleBusinessShortcutFallback(token, wantedSlug);
+    }
     return null;
   }
 
@@ -2248,7 +2289,9 @@ async function computerCreate(token, args = [], defaults = {}) {
     return;
   }
 
-  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug);
+  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug, {
+    allowCanonicalShortcutFallback: Boolean(defaults.allowCanonicalShortcutFallback),
+  });
   if (!ctx?.businessId) {
     console.error('No business found.');
     console.error('Run inside a bound business workspace or pass: --business <slug>');
@@ -3874,6 +3917,7 @@ async function runRecruitingComputerShortcut(token, args, cloudOptions = {}) {
     return computerCreate(token, finalArgs, {
       businessSlug: cloudOptions.businessSlug || RECRUITING_BUSINESS_SLUG,
       computerType: 'recruiting',
+      allowCanonicalShortcutFallback: !cloudOptions.businessSlug,
     });
   }
 
@@ -3888,6 +3932,7 @@ async function runRecruitingComputerShortcut(token, args, cloudOptions = {}) {
   const ctx = await resolveTypedBusinessComputerContext(token, recruitingOptions, {
     businessSlug: RECRUITING_BUSINESS_SLUG,
     computerType: 'recruiting',
+    allowCanonicalShortcutFallback: !recruitingOptions.businessSlug,
   });
   if (!ctx?.businessId) {
     console.error('Atris Recruiting is not available for this account.');

package/commands/gm.js

@@ -331,7 +331,7 @@ function gmState(args = []) {
     missions,
     review_queue: reviewQueue,
     next_commands: commands,
-    xp_rule: 'GM can route missions and review proof, but AgentXP still lands only after human accept.',
+    xp_rule: 'GM can route missions and review proof, but AgentXP is awarded only after human approval.',
     global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
     leaderboard_url: AGENTXP_LEADERBOARD_URL,
   };