atris 3.15.22 → 3.15.30

package/commands/mission.js

@@ -132,6 +132,79 @@ function printJsonOrText(payload, lines, asJson) {
   for (const line of lines) console.log(line);
 }
 
+function loadTaskDb(asJson = false) {
+  try {
+    return require('../lib/task-db');
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    if (error?.code === 'ERR_UNKNOWN_BUILTIN_MODULE' || /node:sqlite/.test(message)) {
+      exitMissionError('AgentXP mission tasks require Node 22+ with node:sqlite.', 2, asJson);
+    }
+    throw error;
+  }
+}
+
+function writeMissionTaskProjection(taskDb, db, workspaceRoot) {
+  const projection = taskDb.taskProjection(db, { workspaceRoot, limit: 500 });
+  const outPath = path.join(workspaceRoot, '.atris', 'state', 'tasks.projection.json');
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, JSON.stringify(projection, null, 2) + '\n', 'utf8');
+  return { projection, outPath };
+}
+
+function missionTaskRef(task) {
+  return task?.display_id || task?.legacy_ref || String(task?.id || '').replace(/[^a-zA-Z0-9]/g, '').toUpperCase().slice(0, 8);
+}
+
+function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
+  const taskDb = loadTaskDb(asJson);
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot(root);
+  const title = `Mission XP: ${mission.objective}`;
+  const metadata = {
+    assigned_to: mission.owner,
+    delegate_via: 'mission_goal_loop',
+    created_for_day: todayName(),
+    goal_id: mission.id,
+    goal_objective: mission.objective,
+    mission_id: mission.id,
+    mission_objective: mission.objective,
+    mission_owner: mission.owner,
+    mission_lane: mission.lane,
+    mission_runner: mission.runner,
+    verify: mission.verifier || null,
+    stop_condition: mission.stop_condition || null,
+  };
+  const result = taskDb.addTask(db, {
+    title,
+    tag: 'agent-xp',
+    workspaceRoot,
+    sourceKey: `mission-xp:${mission.id}`,
+    status: 'claimed',
+    claimedBy: mission.owner,
+    metadata,
+  });
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot }));
+  const task = rows.find(row => row.id === result.id);
+  if (task) {
+    taskDb.noteTask(db, {
+      id: task.id,
+      actor: process.env.ATRIS_AGENT_ID || mission.owner || 'mission-lead',
+      content: `Mission goal loop XP bridge for ${mission.id}. Proof goes through task ready; AgentXP lands only after human accept.`,
+    });
+  }
+  const { outPath } = writeMissionTaskProjection(taskDb, db, workspaceRoot);
+  return {
+    task_id: result.id,
+    ref: missionTaskRef(task) || result.id,
+    title,
+    status: task?.status || 'claimed',
+    assigned_to: mission.owner,
+    inserted: result.inserted !== false,
+    projection_path: outPath,
+  };
+}
+
 function statePaths(root = process.cwd()) {
   const stateDir = path.join(root, '.atris', 'state');
   return {
@@ -323,6 +396,7 @@ function renderMemberNowMarkdown(owner, missions) {
     lines.push(`- cadence: ${mission.cadence}`);
     lines.push(`- runner: ${mission.runner}`);
     lines.push(`- lane: ${mission.lane}`);
+    if (mission.xp_task?.ref) lines.push(`- AgentXP task: ${mission.xp_task.ref}`);
     if (mission.verifier) lines.push(`- verifier: ${mission.verifier}`);
     if (mission.stop_condition) lines.push(`- stop: ${mission.stop_condition}`);
     if (mission.next_action) lines.push(`- next: ${mission.next_action}`);
@@ -366,6 +440,7 @@ function renderMissionStatus(root = process.cwd()) {
       lines.push(`  - owner: ${mission.owner}`);
       lines.push(`  - state: ${mission.status}`);
       lines.push(`  - next: ${mission.next_action || 'tick or verify'}`);
+      if (mission.xp_task?.ref) lines.push(`  - AgentXP task: ${mission.xp_task.ref}`);
       if (mission.receipt_path) lines.push(`  - proof: ${mission.receipt_path}`);
     }
     lines.push('');
@@ -376,6 +451,18 @@ function renderMissionStatus(root = process.cwd()) {
   return paths.statusNow;
 }
 
+function missionXpTaskRefFromMission(mission) {
+  if (mission?.xp_task?.ref) return mission.xp_task.ref;
+  if (mission?.xp_task_enabled && mission?.task_ids?.[0]) return mission.task_ids[0];
+  return '';
+}
+
+function missionXpReadyAction(mission, receiptPath) {
+  const ref = missionXpTaskRefFromMission(mission);
+  if (!ref || !receiptPath) return null;
+  return `queue AgentXP review: atris task ready ${ref} --proof "${receiptPath}"`;
+}
+
 function missionFromArgs(args) {
   const objective = stripKnownFlags(args, [
     '--owner',
@@ -387,7 +474,7 @@ function missionFromArgs(args) {
     '--stop',
     '--task',
     '--ask',
-  ], ['--json', '--always-on']).join(' ').trim();
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp']).join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual]', 1, wantsJson(args));
   }
@@ -401,6 +488,7 @@ function missionFromArgs(args) {
   const taskIds = readRepeatedFlag(args, '--task');
   const humanAsks = readRepeatedFlag(args, '--ask');
   const alwaysOn = hasFlag(args, '--always-on');
+  const xpTaskEnabled = hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp');
   const id = missionId(objective);
   const mission = {
     schema: 'atris.mission.v1',
@@ -414,6 +502,7 @@ function missionFromArgs(args) {
     lane,
     verifier,
     always_on: alwaysOn,
+    xp_task_enabled: xpTaskEnabled,
     stop_condition: stopCondition,
     task_ids: taskIds,
     human_asks: humanAsks,
@@ -437,6 +526,14 @@ function missingVerifierWarning(mission) {
 function startMission(args) {
   const asJson = wantsJson(args);
   const mission = missionFromArgs(args);
+  if (mission.xp_task_enabled) {
+    const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
+    mission.xp_task = xpTask;
+    mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
+    if (!mission.verifier && !mission.always_on) {
+      mission.next_action = `work task then run: atris task ready ${xpTask.ref} --proof "<proof>"`;
+    }
+  }
   const warnings = [missingVerifierWarning(mission)].filter(Boolean);
   ensureMemberMissionFile(mission.owner, process.cwd(), mission.objective);
   const { mission: saved } = saveMission(mission, process.cwd(), 'mission_started', { objective: mission.objective });
@@ -455,6 +552,7 @@ function startMission(args) {
       `Owner: ${saved.owner}`,
       `State: ${saved.status}`,
       ...warnings.map((warning) => `Warning: ${warning.message}`),
+      ...(saved.xp_task ? [`AgentXP task: ${saved.xp_task.ref}`] : []),
       `Next: atris mission tick ${saved.id}`,
     ],
     asJson,
@@ -694,6 +792,10 @@ function codexGoalObjective(mission) {
 }
 
 function codexGoalNextCommand(mission) {
+  if (mission.status === 'ready') {
+    const xpAction = missionXpReadyAction(mission, mission.receipt_path);
+    if (xpAction) return xpAction.replace(/^queue AgentXP review: /, '');
+  }
   if (mission.verifier && missionDueAt(mission)) {
     return 'atris mission run --due --max-ticks 1 --complete-on-pass';
   }
@@ -1294,7 +1396,9 @@ async function runMission(args) {
         worktree: tickWorktree,
       });
 
+      const xpReadyAction = missionXpReadyAction(mission, receiptPath);
       const newStatus = (verifierResult?.passed && mission.always_on) ? 'running' :
+                        (verifierResult?.passed && xpReadyAction) ? 'ready' :
                         (verifierResult?.passed && completeOnPass) ? 'complete' :
                         (verifierResult?.passed ? 'ready' :
                         (verifierResult ? 'blocked' :
@@ -1302,6 +1406,8 @@ async function runMission(args) {
       let nextAction = mission.next_action;
       if (verifierResult?.passed && mission.always_on) {
         nextAction = nextCandidateTickAction(mission);
+      } else if (verifierResult?.passed && xpReadyAction) {
+        nextAction = xpReadyAction;
       } else if (verifierResult?.passed && completeOnPass) {
         nextAction = 'mission complete';
       } else if (verifierResult?.passed) {
@@ -1482,9 +1588,10 @@ function tickMission(args) {
     let status = 'running';
     let nextAction = mission.verifier ? `run verifier: ${mission.verifier}` : 'attach task, verifier, or proof';
     if (verifierResult?.passed) {
-      status = (completeOnPass && !mission.always_on) ? 'complete' : 'ready';
+      const xpReadyAction = missionXpReadyAction(mission, receiptPath);
+      status = (completeOnPass && !mission.always_on && !xpReadyAction) ? 'complete' : 'ready';
       nextAction = mission.always_on ? nextCandidateTickAction(mission) :
-        (completeOnPass ? 'mission complete' : `review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`);
+        (xpReadyAction || (completeOnPass ? 'mission complete' : `review proof then run: atris mission complete ${mission.id} --proof "${receiptPath}"`));
     } else if (verifierResult) {
       status = 'blocked';
       nextAction = 'fix verifier failure or revise mission';
@@ -1549,9 +1656,10 @@ function completeMission(args) {
   const { mission: saved } = saveMission(next, process.cwd(), 'mission_completed', { proof });
   const logPath = appendMemberLog(saved.owner, 'Mission completed', { mission: saved.objective, proof });
   const codexGoalState = refreshCodexGoalController(process.cwd());
+  const xpNextCommand = missionXpReadyAction(saved, proof);
   printJsonOrText(
-    { ok: true, action: 'mission_completed', mission: saved, log_path: logPath, codex_goal_state: codexGoalState },
-    [`Completed mission: ${saved.objective}`, `Proof: ${proof}`],
+    { ok: true, action: 'mission_completed', mission: saved, log_path: logPath, codex_goal_state: codexGoalState, xp_next_command: xpNextCommand },
+    [`Completed mission: ${saved.objective}`, `Proof: ${proof}`, ...(xpNextCommand ? [`AgentXP: ${xpNextCommand}`] : [])],
     asJson,
   );
 }
@@ -1683,7 +1791,7 @@ function help() {
   console.log(`
 atris mission - durable goal + loop + owner + proof state
 
-  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on]
+  atris mission start "<objective>" --owner <member> [--verify "..."] [--always-on] [--xp-task]
   atris mission status [id] [--status <state>] [--limit <n>] [--json]
   atris mission goal [--heartbeat] [--json]
   atris mission goal-loop [--max-wall 28800] [--max-iterations 32] [--no-claude] [--json]
@@ -1696,13 +1804,15 @@ atris mission - durable goal + loop + owner + proof state
 Autonomy recipe:
   1. Pick an owner member: atris member create <member>  (if missing)
   2. Start a current-agent mission with a verifier:
-     atris mission start "ship one proof" --owner <member> --runner codex_goal --lane code --verify "npm test" --stop "verifier passes"
+     atris mission start "ship one proof" --owner <member> --runner codex_goal --lane code --verify "npm test" --stop "verifier passes" --xp-task
   3. Codex sessions: atris mission goal --json, then set /goal to goal.objective
      Overnight controller: atris mission goal --heartbeat --json
      Bounded overnight runner: atris mission goal-loop --max-wall 28800 --no-claude --json
   4. Do one bounded step, then record it:
      atris mission tick <id> --verify --summary "what changed"
   5. Close or continue from the receipt:
+     atris task ready <xp_task_ref> --proof "<receipt_path>"  (if --xp-task)
+     atris task accept <xp_task_ref> --reward <n>             (human accept mints AgentXP)
      atris mission complete <id> --proof "<receipt_path>"
      repeat status -> step -> tick for current-agent work
      atris mission run <id> --max-ticks 4 --complete-on-pass  (Claude/always-on runner)

package/commands/play.js

@@ -6,6 +6,8 @@ const fs = require('fs');
 const { spawnSync } = require('child_process');
 const { getSessionProfile, loadCredentials } = require('../utils/auth');
 
+const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
+
 function showHelp() {
   console.log('');
   console.log('Usage: atris play [--as <player>] [--workspace <path>] [--json]');
@@ -252,10 +254,17 @@ function starterMissionPrompt(player) {
   ].join(' ');
 }
 
+function globalSyncCommands(player) {
+  return [
+    'atris login',
+    `atris xp sync --local --as ${player}`,
+  ];
+}
+
 function ensureStarterMission(taskDb, db, workspaceRoot, player, tasks, args = []) {
   if (hasFlag(args, '--no-seed')) return { tasks, seeded: null };
   if (selectMission(tasks, player)) return { tasks, seeded: null };
-  if (!fs.existsSync(path.join(workspaceRoot, 'atris'))) return { tasks, seeded: null };
+  fs.mkdirSync(path.join(workspaceRoot, 'atris'), { recursive: true });
 
   const result = taskDb.addTask(db, {
     title: starterMissionTitle(),
@@ -282,7 +291,21 @@ function ensureStarterMission(taskDb, db, workspaceRoot, player, tasks, args = [
   return { tasks: refreshed, seeded };
 }
 
+function playWorkspaceRoot(taskDb, workspaceArg) {
+  let requested = path.resolve(workspaceArg || process.cwd());
+  try { requested = fs.realpathSync(requested); } catch {}
+  if (
+    fs.existsSync(path.join(requested, '.git'))
+    || fs.existsSync(path.join(requested, 'atris'))
+    || fs.existsSync(path.join(requested, '.atris'))
+  ) {
+    return taskDb.workspaceRoot(requested);
+  }
+  return requested;
+}
+
 function nextCommands(task, player) {
+  const helper = 'game-manager';
   if (!task) {
     return [
       `atris task delegate "AgentXP first rep: one proof-backed mission" --to ${player} --tag agent-xp`,
@@ -293,40 +316,45 @@ function nextCommands(task, player) {
   const ref = taskRef(task);
   if (task.status === 'open') {
     return [
-      `atris task claim ${ref} --as ${player}`,
-      `atris task ready ${ref} --proof "<artifact path + verifier result>"`,
-      `atris task accept ${ref} --proof "<human review>"`,
+      `atris task claim ${ref} --as ${helper}`,
+      `atris task ready ${ref} --as ${helper} --proof "<artifact path + verifier result>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   if (task.status === 'claimed') {
+    const actor = task.claimed_by || helper;
     return [
-      `atris task ready ${ref} --proof "<artifact path + verifier result>"`,
-      `atris task accept ${ref} --proof "<human review>"`,
+      `atris task ready ${ref} --as ${actor} --proof "<artifact path + verifier result>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   if (task.status === 'review') {
     return [
       `atris task show ${ref}`,
-      `atris task accept ${ref} --proof "<human review>"`,
-      `atris task revise ${ref} --note "<what must change>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
+      `atris task revise ${ref} --as ${player} --note "<what must change>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   return [
     `atris task show ${ref}`,
     'atris xp card --local',
+    ...globalSyncCommands(player),
   ];
 }
 
 function modeState(args = []) {
   const taskDb = require('../lib/task-db');
   const workspaceArg = flag(args, '--workspace') || flag(args, '--root') || process.cwd();
-  const workspaceRoot = taskDb.workspaceRoot(path.resolve(workspaceArg));
+  const workspaceRoot = playWorkspaceRoot(taskDb, workspaceArg);
   const db = taskDb.open();
   const rows = taskDb.listTasks(db, {
     workspaceRoot,
@@ -367,6 +395,8 @@ function modeState(args = []) {
       prompt: latestMessage(events),
     } : null,
     xp_rule: 'AgentXP lands only after proof is ready and a human accepts the task.',
+    global_sync_rule: 'Run atris login once before syncing to the hosted AgentXP leaderboard.',
+    leaderboard_url: AGENTXP_LEADERBOARD_URL,
     next_commands: commandList,
   };
 }
@@ -399,6 +429,8 @@ 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: run atris login once before hosted leaderboard sync.');
+  console.log(`Leaderboard: ${state.leaderboard_url}`);
   console.log('');
   console.log('Next commands:');
   for (const command of state.next_commands) console.log(`- ${command}`);

package/commands/sync.js

@@ -48,6 +48,10 @@ function _substituteParams(content, params) {
     .replace(/\{\{workspace_template\}\}/g, params.workspace_template || 'business');
 }
 
+function _templateTargetRelPath(relPath) {
+  return relPath === 'persona.md' ? 'PERSONA.md' : relPath;
+}
+
 /**
  * Sync the canonical skill set from atris-cli/atris/skills/* into a
  * workspace's atris/skills/* (plus ensure .claude/skills/ symlinks).
@@ -212,14 +216,15 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
   const addedList = [], updatedList = [], preservedList = [];
 
   for (const relPath of templateFiles) {
+    const targetRelPath = _templateTargetRelPath(relPath);
     const templatePath = path.join(template.dir, relPath);
-    const targetPath = path.join(targetAtrisDir, relPath);
+    const targetPath = path.join(targetAtrisDir, targetRelPath);
     let templateContent;
     try { templateContent = fs.readFileSync(templatePath, 'utf-8'); } catch { continue; }
     const finalContent = _substituteParams(templateContent, params);
 
     if (!fs.existsSync(targetPath)) {
-      addedList.push(relPath); added++;
+      addedList.push(targetRelPath); added++;
       if (!dryRun) {
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
         fs.writeFileSync(targetPath, finalContent);
@@ -229,10 +234,10 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
       if (existing === finalContent) {
         skipped++;
       } else if (force) {
-        updatedList.push(relPath); updated++;
+        updatedList.push(targetRelPath); updated++;
         if (!dryRun) fs.writeFileSync(targetPath, finalContent);
       } else {
-        preservedList.push(relPath); preserved++;
+        preservedList.push(targetRelPath); preserved++;
       }
     }
   }

package/commands/xp.js

@@ -17,6 +17,7 @@ const CAREER_XP_SESSIONS_DIR = path.join('.atris', 'state', 'career_xp_sessions'
 const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
 const CODEX_STATE_FILE = path.join(os.homedir(), '.codex', 'state_5.sqlite');
 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 XP_STATE_FILES = new Set([
@@ -37,14 +38,16 @@ const SEARCH_EXCLUDED_DIRS = new Set([
 const DEFAULT_SEARCH_DEPTH = 6;
 
 function showHelp() {
-  console.log('Usage: atris xp [card|status|collect|session] [--json] [--workspace <path>] [--all] [--root <path>]');
+  console.log('Usage: atris xp [card|status|collect|session|sync] [--json] [--workspace <path>] [--all] [--root <path>]');
   console.log('       atris xp session [--since today|tonight|YYYY-MM-DD] [--until <time>] [--mission <text>] [--thread <id>] [--no-write]');
+  console.log('       atris xp sync [--as <player>] [--local|--all] [--token <token>|logged-in] [--dry-run] [--json]');
   console.log('       atris xp [--json] [--local] [--workspace <path>] [--operator <name>]');
   console.log('');
   console.log('Show your AgentXP graph for the active Atris account.');
   console.log('Use status to show account-level AgentXP across verified local ledgers.');
   console.log('Use collect or status --local to project accepted task proof in the current workspace.');
   console.log('Use session to encapsulate the current work window into a local XP capsule.');
+  console.log('Use sync to upload a path-private AgentXP packet to the hosted leaderboard.');
   console.log('Use status --all to explicitly aggregate verified local XP ledgers across workspaces.');
   console.log('Use --local to render from proof receipts in the current workspace.');
 }
@@ -187,6 +190,14 @@ function readFlag(args, name, fallback = null) {
   return fallback;
 }
 
+function readFirstFlag(args, names, fallback = null) {
+  for (const name of names) {
+    const value = readFlag(args, name, null);
+    if (value !== null && value !== undefined && value !== '') return value;
+  }
+  return fallback;
+}
+
 function readFlagValues(args, names) {
   const wanted = Array.isArray(names) ? names : [names];
   const values = [];
@@ -312,6 +323,15 @@ function hashPayload(value) {
   return sha256(canonicalJson(value));
 }
 
+function slugify(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/@.*$/, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
 function readJsonFile(filePath, fallback = null) {
   if (!fs.existsSync(filePath)) return fallback;
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -1418,7 +1438,191 @@ function loadLocalPayload(args) {
   return normalizeLocalScore(JSON.parse(result.stdout), workspace);
 }
 
+function publicAgentXp(value) {
+  return Math.max(0, Math.min(99, asNumber(value)));
+}
+
+function verifiedProjection(projection) {
+  return projection?.integrity_status === 'verified'
+    && projection?.integrity?.status === 'verified';
+}
+
+function projectionWorkspaceSummaries(projection) {
+  if (Array.isArray(projection?.workspaces)) {
+    return projection.workspaces.map(workspace => ({
+      name: workspace.name || workspaceName(workspace.workspace_root || 'workspace'),
+      workspace_root_hash: workspace.workspace_root ? sha256(path.resolve(workspace.workspace_root)) : null,
+      included: Boolean(workspace.included),
+      agent_xp: asNumber(workspace.total_xp),
+      receipts_count: asNumber(workspace.receipts_count),
+      integrity_status: workspace.integrity_status || 'unknown',
+    }));
+  }
+
+  const workspaceRoot = projection?.workspace_root || path.resolve(process.cwd());
+  return [{
+    name: workspaceName(workspaceRoot),
+    workspace_root_hash: sha256(path.resolve(workspaceRoot)),
+    included: verifiedProjection(projection),
+    agent_xp: asNumber(projection?.total_agent_xp ?? projection?.total_xp),
+    receipts_count: asNumber(projection?.receipts_count),
+    integrity_status: projection?.integrity_status || projection?.integrity?.status || 'unknown',
+  }];
+}
+
+function syncPlayer(args, projection) {
+  const explicit = readFirstFlag(args, ['--as', '--player', '--user', '--operator'], null);
+  return slugify(
+    explicit
+    || process.env.ATRIS_PLAYER
+    || process.env.ATRIS_USERNAME
+    || process.env.ATRIS_PROFILE
+    || process.env.USER
+    || os.userInfo().username
+    || projection?.operator
+    || 'player'
+  ) || 'player';
+}
+
+function buildAgentXpSyncPacket(args = []) {
+  const localMode = hasFlag(args, '--local') || hasFlag(args, '--workspace') || hasFlag(args, '--operator');
+  const projectionArgs = args.filter(arg => !['--dry-run', '--no-post', '--packet'].includes(arg));
+  const projection = hasFlag(args, '--all') || !localMode
+    ? collectAllLocalXpProjection(projectionArgs)
+    : collectLocalXpProjection(projectionArgs);
+  const player = syncPlayer(args, projection);
+  const workspaces = projectionWorkspaceSummaries(projection);
+  const totalXp = asNumber(projection.total_agent_xp ?? projection.agent_xp ?? projection.total_xp ?? projection.career_xp);
+  const receiptsCount = asNumber(projection.receipts_count);
+  const eligible = verifiedProjection(projection) && receiptsCount > 0 && totalXp > 0;
+  const publicXp = publicAgentXp(totalXp);
+  const entry = {
+    user_id: player,
+    username: player,
+    agent_xp: publicXp,
+    career_xp: publicXp,
+    current_form: publicXp,
+    ovr: publicXp,
+    level: Math.max(1, asNumber(projection.level, 1)),
+    verified_receipts: receiptsCount,
+    reviewed_tasks: receiptsCount,
+    recent_verified_receipts: receiptsCount,
+    recent_reviewed_tasks: receiptsCount,
+    leaderboard_eligible: eligible,
+    integrity_status: eligible ? 'trusted' : (projection.integrity_status || projection.integrity?.status || 'unknown'),
+    lock_reason: eligible ? null : 'not_enough_trusted_proof',
+    public_adjustment: null,
+    next_move: eligible ? 'Play the next proof-backed AgentXP mission.' : 'Complete one proof-backed AgentXP rep.',
+  };
+  const packet = {
+    schema: 'atris.agentxp_sync_packet.v1',
+    generated_at: new Date().toISOString(),
+    workspace_root_hash: sha256(workspaces.map(item => item.workspace_root_hash || item.name).sort().join(':')),
+    computer: projection.workspace_name || workspaces[0]?.name || 'local',
+    operator: player,
+    privacy: {
+      raw_proofs_included: false,
+      raw_receipts_included: false,
+      contains_absolute_workspace_root: false,
+      public_user_board_omits_lifetime_xp: true,
+    },
+    sync_contract: {
+      anti_bs_rule: 'No accepted proof-backed task episodes means no AgentXP leaderboard movement.',
+      trust_rule: 'Only verified local ledgers are uploaded; raw proof and paths stay local.',
+    },
+    local_evidence: {
+      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,
+    },
+    user_leaderboard: {
+      schema: 'atris.agentxp_user_leaderboard.v1',
+      score_name: AGENT_XP_LABEL,
+      entries: [entry],
+    },
+  };
+  packet.packet_hash = hashPayload(packet);
+  return {
+    schema: 'atris.agentxp_sync_preview.v1',
+    generated_at: new Date().toISOString(),
+    dry_run: true,
+    player,
+    entry,
+    packet,
+  };
+}
+
+async function syncAgentXp(args = []) {
+  const preview = buildAgentXpSyncPacket(args);
+  const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--no-post') || hasFlag(args, '--packet');
+  if (dryRun) return preview;
+
+  const token = readFlag(args, '--token', process.env.ATRIS_AGENTXP_SYNC_TOKEN || process.env.AGENTXP_SYNC_TOKEN || '');
+  const options = {
+    method: 'POST',
+    body: preview.packet,
+    retries: 0,
+  };
+  if (token) {
+    options.headers = { 'X-AgentXP-Sync-Token': token };
+  } 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})` : ''}.`);
+    }
+    options.token = ensured.credentials.token;
+  }
+
+  const response = await apiRequestJson('/agentxp/leaderboard/sync', options);
+  if (!response.ok) {
+    throw new Error(`AgentXP sync failed: ${response.error || response.status}`);
+  }
+  return {
+    schema: 'atris.agentxp_sync_result.v1',
+    generated_at: new Date().toISOString(),
+    dry_run: false,
+    player: preview.player,
+    entry: preview.entry,
+    packet_hash: preview.packet.packet_hash,
+    server: response.data || {},
+  };
+}
+
+function renderSync(payload) {
+  const entry = payload.entry || {};
+  console.log('AgentXP Sync');
+  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(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
+    return;
+  }
+  const server = payload.server || {};
+  console.log(`Uploaded: accepted ${formatNumber(server.accepted_count)} | stored ${formatNumber(server.stored_count)}`);
+  const acceptedUsernames = Array.isArray(server.accepted_usernames)
+    ? server.accepted_usernames.map(value => String(value || '').trim()).filter(Boolean)
+    : [];
+  if (acceptedUsernames.length) {
+    console.log(`Public identity: ${acceptedUsernames.join(', ')}`);
+  }
+  const player = String(payload.player || entry.username || '').trim().toLowerCase();
+  const accepted = acceptedUsernames.map(value => value.toLowerCase());
+  if (server.mapped_to_authenticated_user === true && player && !accepted.includes(player)) {
+    console.log('Login auth mapped this sync to your Atris account.');
+  }
+  console.log(`Packet ${payload.packet_hash}`);
+  console.log(`Leaderboard: ${AGENTXP_LEADERBOARD_URL}`);
+}
+
 function render(payload) {
+  if (payload.schema === 'atris.agentxp_sync_preview.v1' || payload.schema === 'atris.agentxp_sync_result.v1') {
+    renderSync(payload);
+    return;
+  }
+
   if (payload.schema === 'atris.career_xp_session_capsule.v1') {
     const xp = payload.xp || {};
     const tasks = payload.tasks || {};
@@ -1508,6 +1712,23 @@ async function xpCommand(...args) {
   }
 
   const subcommand = args[0] && !args[0].startsWith('--') ? args[0] : null;
+  if (subcommand === 'sync') {
+    const commandArgs = args.slice(1);
+    let payload;
+    try {
+      payload = await syncAgentXp(commandArgs);
+    } catch (error) {
+      console.error(`Failed to sync AgentXP: ${error.message}`);
+      process.exit(1);
+    }
+    if (args.includes('--json')) {
+      console.log(JSON.stringify(payload, null, 2));
+      return;
+    }
+    render(payload);
+    return;
+  }
+
   if (subcommand === 'session') {
     const commandArgs = args.slice(1);
     let payload;
@@ -1603,6 +1824,8 @@ module.exports = {
   buildCareerXpSessionCapsule,
   collectAllLocalXpProjection,
   collectLocalXpProjection,
+  buildAgentXpSyncPacket,
+  syncAgentXp,
   receiptFromTaskEpisode,
   render,
 };