atris 3.15.31 → 3.15.37

package/commands/xp.js

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

package/lib/runtime-bootstrap.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const path = require('path');
+
+function getAtrisPackageVersion() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
+function writeRuntimeReceipt(workspaceRoot, fields = {}) {
+  const stateDir = path.join(workspaceRoot, '.atris', 'state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  const receipt = {
+    schema: 'atris.runtime.v1',
+    scope: fields.scope || 'local',
+    boundary: fields.boundary || 'manual',
+    atris_version: fields.atris_version || getAtrisPackageVersion(),
+    install_status: fields.install_status || 'recorded',
+    sync_status: fields.sync_status || 'recorded',
+    updated_at: fields.updated_at || new Date().toISOString(),
+    ...fields,
+  };
+  const filePath = path.join(stateDir, 'runtime.json');
+  fs.writeFileSync(filePath, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+  return { filePath, receipt };
+}
+
+function shellQuote(value) {
+  return `'${String(value || '').replace(/'/g, `'\\''`)}'`;
+}
+
+function buildRemoteAtrisBootstrapCommand(options = {}) {
+  const boundary = options.boundary || 'computer-wake';
+  const businessSlug = options.businessSlug || '';
+  const workspaceId = options.workspaceId || '';
+  const businessId = options.businessId || '';
+
+  return [
+    'set +e',
+    'WORKSPACE="/workspace"',
+    'STATE_DIR="$WORKSPACE/.atris/state"',
+    'mkdir -p "$STATE_DIR"',
+    'RUNTIME_FILE="$STATE_DIR/runtime.json"',
+    'sanitize() { printf "%s" "$1" | tr "\\n\\r" "  " | sed "s/[\\\\\\\"]/ /g" | cut -c1-160; }',
+    'version_text() { if command -v atris >/dev/null 2>&1; then atris version 2>/dev/null || atris --version 2>/dev/null || true; fi; }',
+    'BEFORE="$(sanitize "$(version_text)")"',
+    '[ -n "$BEFORE" ] || BEFORE="missing"',
+    'INSTALL_STATUS="skipped"',
+    'SYNC_STATUS="skipped"',
+    'RECOVERY_COMMAND=""',
+    'if [ "${ATRIS_SKIP_RUNTIME_BOOTSTRAP:-}" = "1" ]; then',
+    '  INSTALL_STATUS="skipped_env"',
+    'elif command -v npm >/dev/null 2>&1; then',
+    '  if npm install -g atris@latest >/tmp/atris-runtime-bootstrap-npm.log 2>&1; then',
+    '    INSTALL_STATUS="installed_latest"',
+    '  else',
+    '    INSTALL_STATUS="failed"',
+    '    RECOVERY_COMMAND="npm install -g atris@latest"',
+    '  fi',
+    'else',
+    '  INSTALL_STATUS="failed_no_npm"',
+    '  RECOVERY_COMMAND="install node/npm, then npm install -g atris@latest"',
+    'fi',
+    'AFTER="$(sanitize "$(version_text)")"',
+    '[ -n "$AFTER" ] || AFTER="missing"',
+    'if command -v atris >/dev/null 2>&1 && [ -d "$WORKSPACE/atris" ]; then',
+    '  if (cd "$WORKSPACE" && ATRIS_SKIP_UPDATE_CHECK=1 atris update >/tmp/atris-runtime-bootstrap-sync.log 2>&1); then',
+    '    SYNC_STATUS="synced"',
+    '  else',
+    '    SYNC_STATUS="failed"',
+    '  fi',
+    'fi',
+    'UPDATED_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"',
+    `BOUNDARY=${shellQuote(boundary)}`,
+    `BUSINESS_SLUG=${shellQuote(businessSlug)}`,
+    `BUSINESS_ID=${shellQuote(businessId)}`,
+    `WORKSPACE_ID=${shellQuote(workspaceId)}`,
+    'cat > "$RUNTIME_FILE" <<JSON',
+    '{',
+    '  "schema": "atris.runtime.v1",',
+    '  "scope": "remote-business-computer",',
+    '  "boundary": "$BOUNDARY",',
+    '  "business_slug": "$BUSINESS_SLUG",',
+    '  "business_id": "$BUSINESS_ID",',
+    '  "workspace_id": "$WORKSPACE_ID",',
+    '  "atris_before": "$BEFORE",',
+    '  "atris_after": "$AFTER",',
+    '  "install_status": "$INSTALL_STATUS",',
+    '  "sync_status": "$SYNC_STATUS",',
+    '  "recovery_command": "$RECOVERY_COMMAND",',
+    '  "updated_at": "$UPDATED_AT"',
+    '}',
+    'JSON',
+    'echo "atris_runtime_bootstrap install=$INSTALL_STATUS version=$AFTER sync=$SYNC_STATUS receipt=.atris/state/runtime.json"',
+    'if [ -n "$RECOVERY_COMMAND" ]; then echo "recovery=$RECOVERY_COMMAND"; fi',
+    'exit 0',
+  ].join('\n');
+}
+
+module.exports = {
+  buildRemoteAtrisBootstrapCommand,
+  getAtrisPackageVersion,
+  writeRuntimeReceipt,
+};

package/package.json

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