atris 3.15.55 → 3.15.57

package/bin/atris.js

@@ -1567,7 +1567,7 @@ if (command === 'init') {
   searchJournal(keyword);
 } else if (command === 'xp') {
   require('../commands/xp').xpCommand(...process.argv.slice(3))
-    .then(() => process.exit(0))
+    .then(() => { process.exitCode = 0; })
     .catch((err) => { console.error(`✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'play') {
   require('../commands/play').playCommand(...process.argv.slice(3))

package/commands/computer.js

@@ -2550,34 +2550,56 @@ async function streamBusinessChatResult(token, ctx, executionId, rl = null, opti
 
       errors = 0;
       let done = false;
-      for (const event of (events.data?.events || [])) {
-        fromIndex++;
-        if (event.type === 'assistant_text' && event.content) {
-          sawVisibleOutput = true;
-          process.stdout.write(event.content);
-        } else if (event.type === 'result' && event.result && !sawVisibleOutput) {
-          sawVisibleOutput = true;
-          process.stdout.write(String(event.result));
-        } else if (!options.quiet && event.type === 'tool_use' && event.tool) {
-          const arg = event.input?.file_path || event.input?.path || event.input?.pattern || event.input?.command || '';
-          if (arg) {
-            console.log(`\n  [${event.tool}] ${String(arg).slice(0, 120)}`);
-          } else {
-            console.log(`\n  [${event.tool}]`);
+      const emitEvents = (items, { showTools = true } = {}) => {
+        let batchDone = false;
+        for (const event of (items || [])) {
+          if ((event.type === 'assistant_text' || event.type === 'text') && event.content) {
+            sawVisibleOutput = true;
+            process.stdout.write(event.content);
+          } else if (event.type === 'result' && event.result && !sawVisibleOutput) {
+            sawVisibleOutput = true;
+            process.stdout.write(String(event.result));
+          } else if (showTools && !options.quiet && event.type === 'tool_use' && event.tool) {
+            const arg = event.input?.file_path || event.input?.path || event.input?.pattern || event.input?.command || '';
+            if (arg) {
+              console.log(`\n  [${event.tool}] ${String(arg).slice(0, 120)}`);
+            } else {
+              console.log(`\n  [${event.tool}]`);
+            }
+          } else if (event.type === 'error') {
+            if (event.error) console.error(`\n${event.error}`);
+            terminalStatus = 'error';
+            batchDone = true;
+            break;
+          } else if (event.type === 'complete') {
+            terminalStatus = 'completed';
+            batchDone = true;
+            break;
           }
-        } else if (event.type === 'error') {
-          if (event.error) console.error(`\n${event.error}`);
-          terminalStatus = 'error';
-          done = true;
-          break;
-        } else if (event.type === 'complete') {
-          terminalStatus = 'completed';
-          done = true;
-          break;
         }
+        return batchDone;
+      };
+
+      const batch = events.data?.events || [];
+      done = emitEvents(batch);
+      const nextIndex = events.data?.next_index;
+      if (Number.isInteger(nextIndex) && nextIndex >= fromIndex) {
+        fromIndex = nextIndex;
+      } else {
+        fromIndex += batch.length;
       }
 
       if (done || ['completed', 'error', 'failed', 'cancelled'].includes(events.data?.status)) {
+        if (!sawVisibleOutput && events.data?.status === 'completed') {
+          const fullEvents = await apiRequestJson(
+            `/business/${ctx.businessId}/chat/events?execution_id=${executionId}&workspace_id=${ctx.workspaceId}&from_index=0`,
+            { method: 'GET', token, timeoutMs: 60000 }
+          );
+          if (fullEvents.ok) {
+            emitEvents(fullEvents.data?.events || [], { showTools: false });
+          }
+        }
+
         if (!process.stdout.write('\n')) {
           // no-op: keep line handling stable
         }

package/commands/integrations.js

@@ -10,6 +10,8 @@
  *   atris calendar date YYYY-MM-DD - Show events on a date
  *   atris twitter post      - Post a tweet (interactive)
  *   atris slack channels    - List Slack channels
+ *   atris slack messages <channel> [--limit 20] - Read recent messages
+ *   atris slack search <query> [--limit 20] - Search Slack messages
  */
 
 const { loadCredentials, ensureValidCredentials } = require('../utils/auth');
@@ -163,6 +165,29 @@ function localDateBounds(dateText) {
   return { start, end };
 }
 
+function calendarEventTimeValue(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  return value.dateTime || value.date || '';
+}
+
+function isDateOnly(value) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(String(value || ''));
+}
+
+function formatCalendarTimeRange(event) {
+  const start = calendarEventTimeValue(event.start || event.start_time || event.startTime);
+  const end = calendarEventTimeValue(event.end || event.end_time || event.endTime);
+  if (!start || isDateOnly(start)) return 'All day';
+  const startDate = new Date(start);
+  if (Number.isNaN(startDate.getTime())) return 'Time unavailable';
+  const startText = startDate.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+  if (!end || isDateOnly(end)) return startText;
+  const endDate = new Date(end);
+  if (Number.isNaN(endDate.getTime())) return startText;
+  return `${startText}-${endDate.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })}`;
+}
+
 function formatCalendarEvents(label, events) {
   if (events.length === 0) {
     console.log(`No events ${label}. 🎉`);
@@ -172,8 +197,7 @@ function formatCalendarEvents(label, events) {
   console.log('─'.repeat(50));
 
   for (const event of events) {
-    const start = event.start?.dateTime || event.start?.date || '';
-    const time = start ? new Date(start).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' }) : 'All day';
+    const time = formatCalendarTimeRange(event);
     const title = event.summary || '(no title)';
 
     console.log(`${time}  ${title}`);
@@ -331,7 +355,7 @@ async function slackChannels() {
 
   console.log('💬 Fetching Slack channels...\n');
 
-  const result = await apiRequestJson('/integrations/slack/channels', {
+  const result = await apiRequestJson('/integrations/slack/me/channels', {
     method: 'GET',
     token,
   });
@@ -359,19 +383,161 @@ async function slackChannels() {
   for (const ch of channels) {
     const name = ch.name || ch.id;
     const priv = ch.is_private ? '🔒' : '#';
-    console.log(`  ${priv} ${name}`);
+    console.log(`  ${priv} ${name}  ${ch.id || ''}`.trimEnd());
   }
 }
 
+async function slackDms() {
+  const token = await getAuthToken();
+
+  console.log('💬 Fetching Slack DMs...\n');
+
+  const result = await apiRequestJson('/integrations/slack/me/dms', {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to fetch DMs'}`);
+    process.exit(1);
+  }
+
+  const dms = result.data?.dms || result.data?.channels || result.data || [];
+  if (!dms.length) {
+    console.log('No DMs found.');
+    return;
+  }
+  for (const dm of dms) {
+    const name = dm.name || dm.user_name || dm.user || dm.id;
+    console.log(`  ${name}  ${dm.id || ''}`.trimEnd());
+  }
+}
+
+function parseLimit(args, fallback = 20) {
+  const idx = args.findIndex((arg) => arg === '--limit' || arg === '-n');
+  const raw = idx >= 0 ? args[idx + 1] : '';
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 100) : fallback;
+}
+
+function argsWithoutLimit(args = []) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--limit' || args[i] === '-n') {
+      i += 1;
+      continue;
+    }
+    out.push(args[i]);
+  }
+  return out;
+}
+
+async function slackPersonalChannels(token) {
+  const result = await apiRequestJson('/integrations/slack/me/channels', {
+    method: 'GET',
+    token,
+  });
+  if (!result.ok) return [];
+  return result.data?.channels || result.data || [];
+}
+
+async function resolveSlackChannel(token, channel) {
+  const text = String(channel || '').trim();
+  if (!text) return '';
+  if (/^[A-Z][A-Z0-9]{5,}$/.test(text)) return text;
+  const wanted = text.replace(/^#/, '').toLowerCase();
+  const channels = await slackPersonalChannels(token);
+  const match = channels.find((ch) => String(ch.name || '').toLowerCase() === wanted || String(ch.id || '').toLowerCase() === wanted);
+  return match?.id || text;
+}
+
+function formatSlackMessages(messages) {
+  if (!messages.length) {
+    console.log('No Slack messages found.');
+    return;
+  }
+  console.log('─'.repeat(60));
+  for (const message of messages) {
+    const author = message.user_name || message.username || message.user || message.sender || 'unknown';
+    const ts = message.datetime || message.time || message.ts || message.created_at || '';
+    const text = String(message.text || message.content || message.message || '').replace(/\s+/g, ' ').trim();
+    console.log(`${ts}  ${author}: ${text || '(no text)'}`);
+  }
+  console.log('─'.repeat(60));
+}
+
+async function slackMessages(channel, args = []) {
+  if (!channel) {
+    console.error('Usage: atris slack messages <channel-or-id> [--limit 20]');
+    process.exit(1);
+  }
+  const token = await getAuthToken();
+  const limit = parseLimit(args);
+  const channelId = await resolveSlackChannel(token, channel);
+
+  console.log(`💬 Reading Slack messages from ${channel}...\n`);
+
+  const result = await apiRequestJson(`/integrations/slack/me/messages/${encodeURIComponent(channelId)}?limit=${limit}`, {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to fetch Slack messages'}`);
+    process.exit(1);
+  }
+
+  const messages = result.data?.messages || result.data || [];
+  formatSlackMessages(messages);
+}
+
+async function slackSearch(query, args = []) {
+  if (!query) {
+    console.error('Usage: atris slack search <query> [--limit 20]');
+    process.exit(1);
+  }
+  const token = await getAuthToken();
+  const limit = parseLimit(args);
+  const q = encodeURIComponent(query);
+
+  console.log(`💬 Searching Slack for "${query}"...\n`);
+
+  const result = await apiRequestJson(`/integrations/slack/me/search?q=${q}&count=${limit}`, {
+    method: 'GET',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to search Slack messages'}`);
+    process.exit(1);
+  }
+
+  const messages = result.data?.messages || result.data?.results || result.data || [];
+  formatSlackMessages(messages);
+}
+
 async function slackCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'channels':
     case 'list':
       await slackChannels();
       break;
+    case 'dms':
+      await slackDms();
+      break;
+    case 'messages':
+    case 'read':
+      await slackMessages(args[0], args.slice(1));
+      break;
+    case 'search':
+      await slackSearch(argsWithoutLimit(args).join(' '), args);
+      break;
     default:
       console.log('Slack commands:');
-      console.log('  atris slack channels    - List Slack channels');
+      console.log('  atris slack channels             - List Slack channels');
+      console.log('  atris slack dms                  - List Slack DMs');
+      console.log('  atris slack messages <channel>   - Read recent messages');
+      console.log('  atris slack search <query>       - Search Slack messages');
   }
 }
 
@@ -448,6 +614,31 @@ function printImessageDoctor(result, json = false) {
   }
 }
 
+function boundedImessageLimit(value) {
+  const parsed = Number(value || 20);
+  if (!Number.isFinite(parsed)) return 20;
+  return Math.max(1, Math.min(100, Math.trunc(parsed)));
+}
+
+function printImessageRows(result, options = {}) {
+  if (options.json) {
+    const rows = String(result.stdout || '').trim();
+    let messages = [];
+    try {
+      messages = rows ? JSON.parse(rows) : [];
+    } catch {
+      messages = [];
+    }
+    console.log(JSON.stringify({
+      ok: result.status === 0,
+      count: Array.isArray(messages) ? messages.length : 0,
+      messages: Array.isArray(messages) ? messages : [],
+    }, null, 2));
+    return;
+  }
+  console.log(String(result.stdout || '').trim() || 'No recent messages found.');
+}
+
 function imessageRecent(handle, options = {}) {
   if (!handle) {
     console.error('Usage: atris imessage recent <phone-or-email> [--limit 20]');
@@ -459,7 +650,7 @@ function imessageRecent(handle, options = {}) {
     process.exit(1);
   }
 
-  const limit = Number(options.limit || 20);
+  const limit = boundedImessageLimit(options.limit);
   const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
   const sql = `
     SELECT datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts,
@@ -469,14 +660,44 @@ function imessageRecent(handle, options = {}) {
     JOIN handle h ON h.rowid = m.handle_id
     WHERE h.id = '${String(handle).replace(/'/g, "''")}'
     ORDER BY m.date DESC
-    LIMIT ${Math.max(1, Math.min(100, limit))};
+    LIMIT ${limit};
   `;
-  const result = spawnSync('sqlite3', ['-readonly', chatDb, sql], { encoding: 'utf8' });
+  const sqliteArgs = options.json ? ['-json', '-readonly', chatDb, sql] : ['-readonly', chatDb, sql];
+  const result = spawnSync('sqlite3', sqliteArgs, { encoding: 'utf8' });
+  if (result.status !== 0) {
+    console.error(result.stderr || 'Failed to read Messages database.');
+    process.exit(1);
+  }
+  printImessageRows(result, options);
+}
+
+function imessageLatest(options = {}) {
+  const doctor = imessageDoctor();
+  if (!doctor.connected) {
+    printImessageDoctor(doctor, Boolean(options.json));
+    process.exit(1);
+  }
+
+  const limit = boundedImessageLimit(options.limit);
+  const chatDb = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+  const sql = `
+    SELECT datetime(m.date/1000000000 + 978307200, 'unixepoch', 'localtime') AS ts,
+           CASE m.is_from_me WHEN 1 THEN 'me' ELSE COALESCE(h.id, 'unknown') END AS sender,
+           COALESCE(h.id, 'unknown') AS handle,
+           replace(replace(COALESCE(m.text,''), char(10), ' '), char(13), ' ') AS text
+    FROM message m
+    LEFT JOIN handle h ON h.rowid = m.handle_id
+    WHERE length(COALESCE(m.text,'')) > 0
+    ORDER BY m.date DESC
+    LIMIT ${limit};
+  `;
+  const sqliteArgs = options.json ? ['-json', '-readonly', chatDb, sql] : ['-readonly', chatDb, sql];
+  const result = spawnSync('sqlite3', sqliteArgs, { encoding: 'utf8' });
   if (result.status !== 0) {
     console.error(result.stderr || 'Failed to read Messages database.');
     process.exit(1);
   }
-  console.log(result.stdout.trim() || 'No recent messages found.');
+  printImessageRows(result, options);
 }
 
 function escapeSqlString(value) {
@@ -1003,12 +1224,22 @@ async function imessageCommand(subcommand, ...args) {
       break;
     }
     case 'recent': {
-      const handle = args[0];
       const limitFlag = args.findIndex((x) => x === '--limit');
       const limit = limitFlag >= 0 ? args[limitFlag + 1] : 20;
+      const handle = args.find((arg) => arg && !arg.startsWith('--') && arg !== String(limit));
+      if (!handle) {
+        imessageLatest({ limit, json: args.includes('--json') });
+        break;
+      }
       imessageRecent(handle, { limit, json: args.includes('--json') });
       break;
     }
+    case 'latest': {
+      const limitFlag = args.findIndex((x) => x === '--limit');
+      const limit = limitFlag >= 0 ? args[limitFlag + 1] : 20;
+      imessageLatest({ limit, json: args.includes('--json') });
+      break;
+    }
     case 'lookup': {
       imessageLookup(args);
       break;
@@ -1022,6 +1253,7 @@ async function imessageCommand(subcommand, ...args) {
       console.log('  atris imessage doctor [--json]   - Check local Messages access');
       console.log('  atris imessage lookup --name <name> [--json] [--refresh]');
       console.log('  atris imessage recent <handle>   - Read recent local messages');
+      console.log('  atris imessage latest [--limit 20] [--json] - Read latest local messages');
       console.log('  atris imessage send --to <handle> --text <text> --approved [--json] [--receipt]');
   }
 }

package/commands/skill.js

@@ -88,6 +88,39 @@ function findAllSkills(skillsDir) {
   return skills;
 }
 
+function localSkillsDir() {
+  return path.join(process.cwd(), 'atris', 'skills');
+}
+
+function bundledSkillsDir() {
+  return path.join(__dirname, '..', 'atris', 'skills');
+}
+
+function readableSkillRoots() {
+  const roots = [localSkillsDir(), bundledSkillsDir()];
+  const seen = new Set();
+  return roots.filter((root) => {
+    if (!root || !fs.existsSync(root)) return false;
+    const real = fs.realpathSync(root);
+    if (seen.has(real)) return false;
+    seen.add(real);
+    return true;
+  });
+}
+
+function findReadableSkills() {
+  const seen = new Set();
+  const skills = [];
+  for (const root of readableSkillRoots()) {
+    for (const skill of findAllSkills(root)) {
+      if (seen.has(skill.folder)) continue;
+      seen.add(skill.folder);
+      skills.push(skill);
+    }
+  }
+  return skills;
+}
+
 // --- Audit Checks ---
 
 function runAuditChecks(skill) {
@@ -355,11 +388,10 @@ function generateTags(folderName, description) {
 // --- Subcommand Handlers ---
 
 function skillList() {
-  const skillsDir = path.join(process.cwd(), 'atris', 'skills');
-  const skills = findAllSkills(skillsDir);
+  const skills = findReadableSkills();
 
   if (skills.length === 0) {
-    console.log('No skills found in atris/skills/. Run "atris init" first.');
+    console.log('No skills found in local or bundled Atris skill roots.');
     return;
   }
 
@@ -396,15 +428,14 @@ function skillList() {
 }
 
 function skillAudit(name) {
-  const skillsDir = path.join(process.cwd(), 'atris', 'skills');
-  const allSkills = findAllSkills(skillsDir);
+  const allSkills = findReadableSkills();
 
   const targets = name === '--all'
     ? allSkills
     : allSkills.filter(s => s.folder === name || s.leafFolder === name);
 
   if (targets.length === 0) {
-    console.error(`Skill "${name}" not found. Run "atris skill list" to see available skills.`);
+    console.error(`Skill "${name}" not found. Run "atris skill list" to see available local and bundled skills.`);
     process.exit(1);
   }
 

package/commands/xp.js

@@ -7,6 +7,7 @@ const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 
 const DEFAULT_GRAPH_DAYS = 365;
+const MAX_SYNC_GRAPH_DAYS = 370;
 const INTENSITY_CHARS = [' ', '.', ':', '*', '#'];
 const ROW_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -210,6 +211,38 @@ function combineAgentXpContributionGraphs(graphs, windowDays = DEFAULT_GRAPH_DAY
   return graphFromDailyTotals(totals, windowDays);
 }
 
+function sanitizeContributionGraphForSync(graph) {
+  if (!graph || typeof graph !== 'object') return null;
+  const rawDays = Array.isArray(graph.days) ? graph.days : [];
+  const days = rawDays
+    .slice(-MAX_SYNC_GRAPH_DAYS)
+    .map((day) => {
+      const date = typeof day?.date === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(day.date)
+        ? day.date
+        : null;
+      if (!date) return null;
+      const xp = Math.max(0, asNumber(day.xp ?? day.total_xp));
+      return {
+        date,
+        xp,
+        total_xp: Math.max(0, asNumber(day.total_xp, xp)),
+        intensity: Math.max(0, Math.min(4, asNumber(day.intensity))),
+      };
+    })
+    .filter(Boolean);
+  if (days.length === 0) return null;
+  return {
+    schema: 'atris.agent_xp_contribution_graph.v1',
+    metric_label: AGENT_XP_LABEL,
+    window_days: days.length,
+    total_xp: days.reduce((sum, day) => sum + day.xp, 0),
+    active_days: days.filter(day => day.xp > 0).length,
+    first_date: days[0]?.date || null,
+    last_date: days[days.length - 1]?.date || null,
+    days,
+  };
+}
+
 function currentForm(payload) {
   const arenas = payload.current_form_by_arena || {};
   const local = arenas.local_workspace || {};
@@ -1123,6 +1156,36 @@ function workspaceName(workspace) {
   return path.basename(workspace) || workspace;
 }
 
+function booleanSetting(value) {
+  if (value === true || value === false) return value;
+  const text = String(value || '').trim().toLowerCase();
+  if (['1', 'true', 'yes', 'public', 'global'].includes(text)) return true;
+  if (['0', 'false', 'no', 'private', 'internal', 'org'].includes(text)) return false;
+  return null;
+}
+
+function agentXpPublicBinding(binding = {}) {
+  const nested = binding.agentxp && typeof binding.agentxp === 'object' ? binding.agentxp : {};
+  const explicit = booleanSetting(
+    binding.agentxp_public
+    ?? binding.public_agentxp
+    ?? binding.agentxp_public_leaderboard
+    ?? nested.public
+    ?? nested.public_agentxp
+  );
+  if (explicit !== null) return explicit;
+
+  const visibility = slugify(binding.agentxp_visibility || nested.visibility);
+  if (visibility === 'public') return true;
+  if (['internal', 'private'].includes(visibility)) return false;
+
+  const scope = slugify(binding.agentxp_scope || nested.scope);
+  if (scope === 'global') return true;
+  if (['org', 'internal', 'private'].includes(scope)) return false;
+
+  return null;
+}
+
 function publicWorkspaceBinding(workspace) {
   const binding = readJsonFile(path.join(workspace, BUSINESS_BINDING_FILE), null);
   if (!binding || typeof binding !== 'object') return null;
@@ -1130,6 +1193,7 @@ function publicWorkspaceBinding(workspace) {
   const workspaceId = String(binding.workspace_id || '').trim();
   const businessSlug = slugify(binding.slug || binding.business_slug || binding.name);
   const workspaceTemplate = slugify(binding.workspace_template || binding.organization_type || binding.computer_type);
+  const agentxpPublic = agentXpPublicBinding(binding);
   if (!businessId && !workspaceId && !businessSlug) return null;
   return {
     business_id: businessId || null,
@@ -1138,6 +1202,7 @@ function publicWorkspaceBinding(workspace) {
     workspace_template: workspaceTemplate || null,
     computer: businessSlug || workspaceName(workspace),
     computer_slug: businessSlug || slugify(workspaceName(workspace)),
+    ...(agentxpPublic === null ? {} : { agentxp_public: agentxpPublic }),
   };
 }
 
@@ -1792,19 +1857,22 @@ function uniqueTruthy(values) {
   return Array.from(new Set(values.map(value => String(value || '').trim()).filter(Boolean))).sort();
 }
 
-function syncAttribution(workspaces) {
+function syncAttribution(workspaces, options = {}) {
   const included = workspaces.filter(workspace => workspace.included !== false);
   const scoped = included.length ? included : workspaces;
   const businessIds = uniqueTruthy(scoped.map(workspace => workspace.business_id));
   const workspaceIds = uniqueTruthy(scoped.map(workspace => workspace.workspace_id));
   const businessSlugs = uniqueTruthy(scoped.map(workspace => workspace.business_slug || workspace.computer_slug));
   const templates = uniqueTruthy(scoped.map(workspace => workspace.workspace_template));
+  const explicitPublic = typeof options.publicAgentXp === 'boolean' ? options.publicAgentXp : null;
+  const workspacePublic = scoped.length === 1 && scoped[0]?.agentxp_public === true;
+  const agentxpPublic = explicitPublic === null ? (workspacePublic ? true : null) : explicitPublic;
 
   if (businessIds.length > 1) {
-    return { attribution_scope: 'multi_business', computer: 'multiple-workspaces' };
+    return { attribution_scope: 'multi_business', computer: 'multiple-workspaces', agentxp_public: explicitPublic === true };
   }
   if (businessIds.length === 0 && scoped.length > 1 && businessSlugs.length > 1) {
-    return { attribution_scope: 'multi_workspace', computer: 'multiple-workspaces' };
+    return { attribution_scope: 'multi_workspace', computer: 'multiple-workspaces', agentxp_public: explicitPublic === true };
   }
 
   const businessId = businessIds[0] || null;
@@ -1818,6 +1886,7 @@ function syncAttribution(workspaces) {
     business_slug: businessSlug,
     workspace_template: workspaceTemplate,
     computer: businessSlug || scoped[0]?.computer || scoped[0]?.name || 'local',
+    agentxp_public: agentxpPublic,
   };
 }
 
@@ -1825,15 +1894,24 @@ function syncScopeFields(attribution = {}) {
   const attributionScope = slugify(attribution.attribution_scope);
   const orgId = String(attribution.business_id || attribution.business_slug || '').trim() || null;
   const businessBound = Boolean(orgId) || attributionScope === 'business-bound' || attributionScope === 'multi-business';
+  const publicAgentXp = typeof attribution.agentxp_public === 'boolean'
+    ? attribution.agentxp_public
+    : !businessBound;
   return {
-    scope: businessBound ? 'org' : 'global',
+    scope: publicAgentXp ? 'global' : (businessBound ? 'org' : 'global'),
     org_id: orgId,
     computer_id: String(attribution.workspace_id || attribution.computer || 'local').trim() || 'local',
-    visibility: businessBound ? 'internal' : 'public',
-    public_agentxp: !businessBound,
+    visibility: publicAgentXp ? 'public' : 'internal',
+    public_agentxp: publicAgentXp,
   };
 }
 
+function publicAgentXpOverride(args = []) {
+  if (hasFlag(args, '--public')) return true;
+  if (hasFlag(args, '--private') || hasFlag(args, '--internal')) return false;
+  return null;
+}
+
 function credentialHandle(credentials) {
   return slugify(
     credentials?.username
@@ -1886,13 +1964,13 @@ function syncPlayer(args, projection) {
 
 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 projectionArgs = args.filter(arg => !['--dry-run', '--no-post', '--packet', '--public', '--private', '--internal'].includes(arg));
   const projection = hasFlag(args, '--all') || !localMode
     ? collectAllLocalXpProjection(projectionArgs)
     : collectLocalXpProjection(projectionArgs);
   const player = syncPlayer(args, projection);
   const workspaces = projectionWorkspaceSummaries(projection);
-  const attribution = syncAttribution(workspaces);
+  const attribution = syncAttribution(workspaces, { publicAgentXp: publicAgentXpOverride(args) });
   const scopeFields = syncScopeFields(attribution);
   const totalXp = asNumber(projection.total_agent_xp ?? projection.agent_xp ?? projection.total_xp ?? projection.career_xp);
   const receiptsCount = asNumber(projection.receipts_count);
@@ -1900,6 +1978,7 @@ function buildAgentXpSyncPacket(args = []) {
   const publicXp = earnedAgentXp(totalXp);
   const currentForm = currentFormScore(totalXp);
   const levelProgress = agentXpLevelProgress(publicXp);
+  const contributionGraph = sanitizeContributionGraphForSync(projection.contribution_graph);
   const workspaceRootHash = sha256(workspaces.map(item => item.workspace_root_hash || item.name).sort().join(':'));
   const entry = {
     user_id: player,
@@ -1919,6 +1998,7 @@ function buildAgentXpSyncPacket(args = []) {
     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.',
+    contribution_graph: contributionGraph,
   };
   const packet = {
     schema: 'atris.agentxp_sync_packet.v1',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.55",
+  "version": "3.15.57",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",