atris 3.15.23 → 3.15.30

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,
 };

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "atris",
-  "version": "3.15.23",
+  "version": "3.15.30",
   "main": "bin/atris.js",
   "bin": {
-    "atris": "bin/atris.js"
+    "atris": "bin/atris.js",
+    "ax": "ax"
   },
   "files": [
+    "ax",
     "bin/",
     "cli/*.py",
     "commands/",
@@ -56,6 +58,7 @@
   ],
   "scripts": {
     "test": "node --test",
+    "publish:release": "node scripts/publish-atris-release.js",
     "prepare": "cp scripts/pre-commit .git/hooks/pre-commit 2>/dev/null && chmod +x .git/hooks/pre-commit || true"
   },
   "keywords": [