atris 2.6.1 → 2.6.2

package/bin/atris.js

@@ -211,6 +211,7 @@ function showHelp() {
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');
   console.log('Setup:');
+  console.log('  setup      - Guided first-time setup (login, pick business, pull)');
   console.log('  init       - Initialize Atris in current project');
   console.log('  update     - Update local files to latest version');
   console.log('  upgrade    - Install latest Atris from npm');
@@ -246,6 +247,14 @@ function showHelp() {
   console.log('');
   console.log('Sync:');
   console.log('  pull       - Pull journals + member data from cloud');
+  console.log('  clean-workspace <slug> - Analyze & remove junk files from a workspace (alias: cw)');
+  console.log('');
+  console.log('Business:');
+  console.log('  business add <slug>    - Connect a business');
+  console.log('  business list          - Show connected businesses');
+  console.log('  business remove <slug> - Disconnect a business');
+  console.log('  business health <slug> - Health report (members, workspace, issues)');
+  console.log('  business audit         - One-line health summary of all businesses');
   console.log('');
   console.log('Cloud & agents:');
   console.log('  console    - Start/attach always-on coding console (tmux daemon)');
@@ -387,7 +396,7 @@ const { planAtris: planCmd, doAtris: doCmd, reviewAtris: reviewCmd } = require('
 const knownCommands = ['init', 'log', 'status', 'analytics', 'visualize', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review',
                        'activate', 'agent', 'chat', 'console', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'verify', 'search', 'skill', 'member', 'plugin', 'experiments', 'pull', 'push', 'business', 'sync',
-                       'gmail', 'calendar', 'twitter', 'slack', 'integrations'];
+                       'gmail', 'calendar', 'twitter', 'slack', 'integrations', 'setup', 'clean-workspace', 'cw'];
 
 // Check if command is an atris.md spec file - triggers welcome visualization
 function isSpecFile(cmd) {
@@ -958,6 +967,11 @@ if (command === 'init') {
   require('../commands/business').businessCommand(subcommand, ...args)
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'clean-workspace' || command === 'cw') {
+  const { cleanWorkspace } = require('../commands/workspace-clean');
+  cleanWorkspace()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'plugin') {
   const subcommand = process.argv[3] || 'build';
   const args = process.argv.slice(4);
@@ -966,6 +980,10 @@ if (command === 'init') {
   const subcommand = process.argv[3];
   const args = process.argv.slice(4);
   require('../commands/experiments').experimentsCommand(subcommand, ...args);
+} else if (command === 'setup') {
+  require('../commands/setup').setupAtris()
+    .then(() => process.exit(0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else {
   console.log(`Unknown command: ${command}`);
   console.log('Run "atris help" to see available commands');

package/commands/business.js

@@ -111,6 +111,242 @@ async function removeBusiness(slug) {
   console.log(`\nRemoved "${name}"`);
 }
 
+// ---------------------------------------------------------------------------
+// Resolve a slug to a business ID using local cache or API lookup
+// ---------------------------------------------------------------------------
+async function resolveSlug(slug, creds) {
+  // Check local cache first
+  const businesses = loadBusinesses();
+  if (businesses[slug]) {
+    return businesses[slug];
+  }
+
+  // Try by-slug endpoint
+  const result = await apiRequestJson(`/businesses/by-slug/${slug}/`, {
+    method: 'GET',
+    token: creds.token,
+  });
+  if (result.ok && result.data) {
+    return { business_id: result.data.id, workspace_id: result.data.workspace_id, name: result.data.name, slug: result.data.slug };
+  }
+
+  // Fallback: list all and match
+  const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+  if (listResult.ok && Array.isArray(listResult.data)) {
+    const match = listResult.data.find(b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase());
+    if (match) {
+      return { business_id: match.id, workspace_id: match.workspace_id, name: match.name, slug: match.slug };
+    }
+  }
+
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Helper: format relative time
+// ---------------------------------------------------------------------------
+function relativeTime(dateStr) {
+  if (!dateStr) return 'unknown';
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+  if (days <= 0) return 'today';
+  if (days === 1) return '1d ago';
+  return `${days}d ago`;
+}
+
+// ---------------------------------------------------------------------------
+// Helper: activity bar
+// ---------------------------------------------------------------------------
+function activityBar(daysSinceActive, width = 10) {
+  const filled = Math.max(0, Math.min(width, width - Math.floor(daysSinceActive / 3)));
+  return '\u2501'.repeat(filled) + '\u2591'.repeat(width - filled);
+}
+
+// ---------------------------------------------------------------------------
+// atris business health <slug>
+// ---------------------------------------------------------------------------
+async function businessHealth(slug) {
+  if (!slug) {
+    console.error('Usage: atris business health <slug>');
+    process.exit(1);
+  }
+
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  const biz = await resolveSlug(slug, creds);
+  if (!biz) {
+    console.error(`Business "${slug}" not found.`);
+    process.exit(1);
+  }
+
+  const bizId = biz.business_id;
+  const wsId = biz.workspace_id;
+
+  // Fetch dashboard and workspace snapshot in parallel
+  const fetchOpts = { method: 'GET', token: creds.token, timeoutMs: 120000 };
+  const [dashResult, wsResult] = await Promise.all([
+    apiRequestJson(`/businesses/${bizId}/dashboard/`, fetchOpts),
+    wsId
+      ? apiRequestJson(`/businesses/${bizId}/workspaces/${wsId}/snapshot?include_content=false`, fetchOpts)
+      : Promise.resolve({ ok: false }),
+  ]);
+
+  const dashboard = dashResult.ok ? dashResult.data : null;
+  const workspace = wsResult.ok ? wsResult.data : null;
+
+  const name = dashboard?.business?.name || biz.name || slug;
+
+  console.log('');
+  console.log(`Business Health: ${name}`);
+  console.log('\u2501'.repeat(26 + name.length));
+  console.log('');
+
+  // Workspace stats
+  const files = workspace?.files || [];
+  const totalSize = files.reduce((sum, f) => sum + (f.size || 0), 0);
+  const fileSizeStr = totalSize > 1024 ? `${Math.round(totalSize / 1024)}KB` : `${totalSize}B`;
+  console.log(`  Workspace:  ${files.length} files, ${fileSizeStr}`);
+
+  // Members
+  const members = dashboard?.roster?.members || dashboard?.members || dashboard?.business?.members || [];
+  const humanMembers = members.filter(m => !m.is_agent && m.role !== 'agent');
+  const agentMembers = members.filter(m => m.is_agent || m.role === 'agent');
+  const memberCountStr = members.length > 0
+    ? `${members.length} (${humanMembers.length} human, ${agentMembers.length} agent)`
+    : `${members.length}`;
+  console.log(`  Members:    ${memberCountStr}`);
+
+  // Apps
+  const apps = dashboard?.business?.apps || dashboard?.apps || [];
+  console.log(`  Apps:       ${Array.isArray(apps) ? apps.length : 0}`);
+
+  // Status
+  const status = dashboard?.business?.status || dashboard?.status || 'unknown';
+  console.log(`  Status:     ${status}`);
+
+  // Member activity
+  if (members.length > 0) {
+    console.log('');
+    console.log('  Member Activity:');
+    for (const m of members) {
+      const memberName = m.display_name || m.name || m.email || 'Unknown';
+      const role = m.role || 'member';
+      const lastActive = m.atris?.last_active || m.last_active || m.last_login || m.joined_at || m.created_at;
+      const daysSince = lastActive ? Math.floor((Date.now() - new Date(lastActive).getTime()) / (1000 * 60 * 60 * 24)) : 999;
+      const bar = activityBar(daysSince);
+      const label = daysSince <= 1 ? 'active' : `last active ${relativeTime(lastActive)}`;
+      console.log(`    ${memberName.padEnd(18)} ${role.padEnd(8)} ${bar} ${label}`);
+    }
+  }
+
+  // Workspace breakdown by directory
+  if (files.length > 0) {
+    console.log('');
+    console.log('  Workspace Breakdown:');
+    const dirSizes = {};
+    for (const f of files) {
+      const filePath = f.path || f.name || '';
+      const dir = filePath.includes('/') ? filePath.split('/')[0] + '/' : '/';
+      dirSizes[dir] = (dirSizes[dir] || 0) + (f.size || 0);
+    }
+    const maxDirSize = Math.max(...Object.values(dirSizes), 1);
+    const sortedDirs = Object.entries(dirSizes).sort((a, b) => b[1] - a[1]);
+    for (const [dir, size] of sortedDirs) {
+      const sizeStr = size > 1024 ? `${Math.round(size / 1024)}KB` : `${size}B`;
+      const barLen = Math.max(1, Math.round((size / maxDirSize) * 10));
+      console.log(`    ${dir.padEnd(12)} ${sizeStr.padStart(5)}   ${'█'.repeat(barLen)}`);
+    }
+  }
+
+  // Issues
+  console.log('');
+  console.log('  Issues:');
+  let hasIssues = false;
+  const humanMembers2 = members.filter(m => m.role !== 'agent');
+  for (const m of humanMembers2) {
+    const lastActive = m.atris?.last_active || m.last_active || m.last_login || m.joined_at || m.created_at;
+    const daysSince = lastActive ? Math.floor((Date.now() - new Date(lastActive).getTime()) / (1000 * 60 * 60 * 24)) : 999;
+    if (daysSince >= 30) {
+      const memberName = m.display_name || m.name || m.email || 'Unknown';
+      console.log(`    \u26A0 ${memberName} inactive for ${daysSince}+ days`);
+      hasIssues = true;
+    }
+  }
+
+  // Check for workspace bloat (arbitrary threshold: >500KB or >100 files)
+  if (totalSize > 500 * 1024) {
+    console.log(`    \u26A0 Workspace large (${fileSizeStr})`);
+    hasIssues = true;
+  }
+  if (files.length > 100) {
+    console.log(`    \u26A0 Workspace has ${files.length} files (consider cleanup)`);
+    hasIssues = true;
+  }
+  if (!hasIssues) {
+    console.log('    \u2713 Workspace clean (no bloat detected)');
+  }
+
+  console.log('');
+}
+
+// ---------------------------------------------------------------------------
+// atris business audit
+// ---------------------------------------------------------------------------
+async function businessAudit() {
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+  if (!listResult.ok || !Array.isArray(listResult.data)) {
+    console.error(`Failed to fetch businesses: ${listResult.error || 'unknown error'}`);
+    process.exit(1);
+  }
+
+  const businesses = listResult.data;
+
+  console.log('');
+  console.log('Business Audit');
+  console.log('\u2501'.repeat(14));
+  console.log('');
+
+  for (const biz of businesses) {
+    const name = biz.name || biz.slug || 'Unknown';
+    const memberCount = typeof biz.member_count === 'number' ? biz.member_count : (Array.isArray(biz.members) ? biz.members.length : 0);
+    const appCount = typeof biz.app_count === 'number' ? biz.app_count : (Array.isArray(biz.apps) ? biz.apps.length : 0);
+
+    // Determine activity status
+    const status = biz.status || 'unknown';
+    const isActive = status === 'active' || (memberCount > 1 && appCount > 0);
+    const hasContent = memberCount > 1 || appCount > 0;
+
+    let icon, activityLabel;
+    if (isActive) {
+      icon = '\u2713';
+      activityLabel = appCount > 0 ? 'active' : 'idle';
+    } else if (hasContent) {
+      icon = '\u26A0';
+      activityLabel = 'inactive';
+    } else {
+      icon = '\u25CB';
+      activityLabel = 'inactive';
+    }
+
+    const memberStr = memberCount === 1 ? '1 member' : `${memberCount} members`;
+    const appStr = appCount === 1 ? '1 app' : `${appCount} apps`;
+
+    console.log(`  ${icon} ${name.padEnd(16)} ${memberStr.padEnd(12)} ${appStr.padEnd(8)} ${activityLabel}`);
+  }
+
+  console.log('');
+}
+
 async function businessCommand(subcommand, ...args) {
   switch (subcommand) {
     case 'add':
@@ -124,9 +360,15 @@ async function businessCommand(subcommand, ...args) {
     case 'rm':
       await removeBusiness(args[0]);
       break;
+    case 'health':
+      await businessHealth(args[0]);
+      break;
+    case 'audit':
+      await businessAudit();
+      break;
     default:
-      console.log('Usage: atris business <add|list|remove> [slug]');
+      console.log('Usage: atris business <add|list|remove|health|audit> [slug]');
   }
 }
 
-module.exports = { businessCommand, loadBusinesses, saveBusinesses, getBusinessConfigPath };
+module.exports = { businessCommand, businessHealth, businessAudit, loadBusinesses, saveBusinesses, getBusinessConfigPath };

package/commands/context-sync.js

@@ -73,10 +73,10 @@ async function businessStatus(slug) {
   if (fs.existsSync(atrisDir)) localDir = atrisDir;
   else if (fs.existsSync(cwdDir)) localDir = cwdDir;
 
-  // Get remote snapshot (hashes only)
+  // Get remote snapshot with content (needed for reliable hash computation)
   const result = await apiRequestJson(
-    `/businesses/${biz.businessId}/workspaces/${biz.workspaceId}/snapshot?include_content=false`,
-    { method: 'GET', token: biz.token }
+    `/businesses/${biz.businessId}/workspaces/${biz.workspaceId}/snapshot?include_content=true`,
+    { method: 'GET', token: biz.token, timeoutMs: 120000 }
   );
 
   if (!result.ok) {
@@ -89,9 +89,11 @@ async function businessStatus(slug) {
   }
 
   const remoteFiles = {};
+  const crypto = require('crypto');
   for (const file of (result.data.files || [])) {
-    if (file.path && !file.binary) {
-      remoteFiles[file.path] = { hash: file.hash, size: file.size || 0 };
+    if (file.path && !file.binary && file.content != null) {
+      const rawBytes = Buffer.from(file.content, 'utf-8');
+      remoteFiles[file.path] = { hash: crypto.createHash('sha256').update(rawBytes).digest('hex'), size: rawBytes.length };
     }
   }
 

package/commands/pull.js

@@ -13,7 +13,7 @@ async function pullAtris() {
   const arg = process.argv[3];
 
   // If a business name is given, do a business pull
-  if (arg && arg !== '--help') {
+  if (arg && arg !== '--help' && !arg.startsWith('--')) {
     return pullBusiness(arg);
   }
 
@@ -80,6 +80,23 @@ async function pullBusiness(slug) {
 
   const force = process.argv.includes('--force');
 
+  // Parse --only flag: comma-separated directory prefixes to filter
+  const onlyArg = process.argv.find(a => a.startsWith('--only='));
+  const onlyPrefixes = onlyArg
+    ? onlyArg.slice('--only='.length).split(',').map(p => {
+        // Normalize: strip leading slash, ensure trailing slash for dirs
+        let norm = p.replace(/^\//, '');
+        if (norm && !norm.endsWith('/') && !norm.includes('.')) norm += '/';
+        return norm;
+      }).filter(Boolean)
+    : null;
+
+  // Parse --timeout flag: override default 120s timeout
+  const timeoutArg = process.argv.find(a => a.startsWith('--timeout='));
+  const timeoutMs = timeoutArg
+    ? parseInt(timeoutArg.slice('--timeout='.length), 10) * 1000
+    : 120000;
+
   // Determine output directory
   const intoIdx = process.argv.indexOf('--into');
   let outputDir;
@@ -94,21 +111,23 @@ async function pullBusiness(slug) {
     }
   }
 
-  // Resolve business ID — check local config first, then API
+  // Resolve business ID — always refresh from API to avoid stale workspace_id
   let businessId, workspaceId, businessName, resolvedSlug;
   const businesses = loadBusinesses();
 
-  if (businesses[slug]) {
-    businessId = businesses[slug].business_id;
-    workspaceId = businesses[slug].workspace_id;
-    businessName = businesses[slug].name || slug;
-    resolvedSlug = businesses[slug].slug || slug;
-  } else {
-    const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
-    if (!listResult.ok) {
+  const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+  if (!listResult.ok) {
+    // Fall back to local cache if API fails
+    if (businesses[slug]) {
+      businessId = businesses[slug].business_id;
+      workspaceId = businesses[slug].workspace_id;
+      businessName = businesses[slug].name || slug;
+      resolvedSlug = businesses[slug].slug || slug;
+    } else {
       console.error(`Failed to fetch businesses: ${listResult.errorMessage || listResult.status}`);
       process.exit(1);
     }
+  } else {
     const match = (listResult.data || []).find(
       b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
     );
@@ -121,6 +140,7 @@ async function pullBusiness(slug) {
     businessName = match.name;
     resolvedSlug = match.slug;
 
+    // Update local cache
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
@@ -143,16 +163,19 @@ async function pullBusiness(slug) {
 
   console.log('');
   console.log(`Pulling ${businessName}...` + (timeSince ? `  (last synced ${timeSince})` : ''));
+  console.log('  Fetching workspace...');
 
   // Get remote snapshot (large workspaces can take 60s+)
   const result = await apiRequestJson(
     `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=true`,
-    { method: 'GET', token: creds.token, timeoutMs: 120000 }
+    { method: 'GET', token: creds.token, timeoutMs }
   );
 
   if (!result.ok) {
-    const msg = result.errorMessage || `HTTP ${result.status}`;
-    if (result.status === 409) {
+    const msg = result.errorMessage || result.error || `HTTP ${result.status}`;
+    if (result.status === 0 || (typeof msg === 'string' && msg.toLowerCase().includes('timeout'))) {
+      console.error(`\n  Workspace is taking too long to respond. Try: atris pull ${slug} --timeout=120`);
+    } else if (result.status === 409) {
       console.error(`\n  Computer is sleeping. Wake it first, then pull again.`);
     } else if (result.status === 403) {
       console.error(`\n  Access denied. You're not a member of "${slug}".`);
@@ -164,18 +187,39 @@ async function pullBusiness(slug) {
     process.exit(1);
   }
 
-  const files = result.data.files || [];
+  let files = result.data.files || [];
   if (files.length === 0) {
     console.log('  Workspace is empty.');
     return;
   }
 
+  console.log(`  Processing ${files.length} files...`);
+
+  // Apply --only filter if specified
+  if (onlyPrefixes) {
+    files = files.filter(file => {
+      if (!file.path) return false;
+      const rel = file.path.replace(/^\//, '');
+      return onlyPrefixes.some(prefix => rel.startsWith(prefix));
+    });
+    if (files.length === 0) {
+      console.log(`  No files matched --only filter: ${onlyPrefixes.join(', ')}`);
+      return;
+    }
+    console.log(`  Filtered to ${files.length} files matching: ${onlyPrefixes.join(', ')}`);
+  }
+
   // Build remote file map {path: {hash, size, content}}
   const remoteFiles = {};
   const remoteContent = {};
   for (const file of files) {
     if (!file.path || file.binary || file.content === null || file.content === undefined) continue;
-    remoteFiles[file.path] = { hash: file.hash || computeFileHash(file.content), size: file.size || 0 };
+    // Skip empty files (deleted files that were blanked out)
+    if (file.content === '') continue;
+    // Compute hash from content bytes (matches computeLocalHashes raw byte hashing)
+    const crypto = require('crypto');
+    const rawBytes = Buffer.from(file.content, 'utf-8');
+    remoteFiles[file.path] = { hash: crypto.createHash('sha256').update(rawBytes).digest('hex'), size: rawBytes.length };
     remoteContent[file.path] = file.content;
   }
 
@@ -265,8 +309,12 @@ async function pullBusiness(slug) {
     // Git might not be initialized yet — that's fine
   }
 
-  // Save manifest
-  const newManifest = buildManifest(remoteFiles, commitHash);
+  // Save manifest — when using --only, merge into existing manifest to avoid data loss
+  let manifestFiles = remoteFiles;
+  if (onlyPrefixes && manifest && manifest.files) {
+    manifestFiles = { ...manifest.files, ...remoteFiles };
+  }
+  const newManifest = buildManifest(manifestFiles, commitHash);
   saveManifest(resolvedSlug || slug, newManifest);
 }
 

package/commands/push.js

@@ -114,16 +114,20 @@ async function pushAtris() {
   console.log('');
   console.log(`Pushing to ${businessName}...`);
 
+  // Get snapshot with content to compute reliable hashes (server hash may differ)
   const snapshotResult = await apiRequestJson(
-    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=false`,
-    { method: 'GET', token: creds.token }
+    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=true`,
+    { method: 'GET', token: creds.token, timeoutMs: 120000 }
   );
 
   let remoteFiles = {};
   if (snapshotResult.ok && snapshotResult.data && snapshotResult.data.files) {
     for (const file of snapshotResult.data.files) {
-      if (file.path && !file.binary) {
-        remoteFiles[file.path] = { hash: file.hash, size: file.size || 0 };
+      if (file.path && !file.binary && file.content != null) {
+        // Compute hash from content (matches how computeLocalHashes works on raw bytes)
+        const rawBytes = Buffer.from(file.content, 'utf-8');
+        const hash = require('crypto').createHash('sha256').update(rawBytes).digest('hex');
+        remoteFiles[file.path] = { hash, size: rawBytes.length };
       }
     }
   }

package/commands/setup.js

@@ -0,0 +1,178 @@
+const fs = require('fs');
+const path = require('path');
+const { loadCredentials, promptUser } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+
+async function setupAtris() {
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  Atris Setup');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  // Step 1: Check Node version
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split('.')[0], 10);
+  if (major < 18) {
+    console.error(`Node.js ${nodeVersion} is too old. Atris requires Node.js 18 or newer.`);
+    console.error('');
+    console.error('Update Node.js:');
+    console.error('  macOS:   brew install node');
+    console.error('  or visit https://nodejs.org/en/download');
+    process.exit(1);
+  }
+  console.log(`  [1/4] Node.js ${nodeVersion} ... OK`);
+
+  // Step 2: Check login status
+  let creds = loadCredentials();
+  if (creds && creds.token) {
+    const label = creds.email || creds.user_id || 'unknown';
+    console.log(`  [2/4] Logged in as ${label} ... OK`);
+  } else {
+    console.log('  [2/4] Not logged in. Starting login...');
+    console.log('');
+    const { loginAtris } = require('./auth');
+    // loginAtris calls process.exit, so we override it temporarily
+    const originalExit = process.exit;
+    let loginCompleted = false;
+    process.exit = (code) => {
+      if (code === 0) {
+        loginCompleted = true;
+        return; // Suppress exit on success so setup can continue
+      }
+      // On failure, actually exit
+      originalExit(code);
+    };
+    try {
+      await loginAtris();
+    } finally {
+      process.exit = originalExit;
+    }
+
+    if (!loginCompleted) {
+      console.error('\nLogin failed. Run "atris setup" again after fixing the issue.');
+      process.exit(1);
+    }
+
+    // Reload credentials after login
+    creds = loadCredentials();
+    if (!creds || !creds.token) {
+      console.error('\nLogin did not produce credentials. Run "atris login" manually, then "atris setup" again.');
+      process.exit(1);
+    }
+    console.log('');
+    console.log(`  [2/4] Logged in ... OK`);
+  }
+
+  // Step 3: Fetch businesses
+  console.log('  [3/4] Fetching your businesses...');
+  let businesses = [];
+  try {
+    const result = await apiRequestJson('/businesses/', {
+      method: 'GET',
+      token: creds.token,
+    });
+
+    if (!result.ok) {
+      console.error(`\n  Could not fetch businesses: ${result.error || 'Unknown error'}`);
+      console.error('  You can add one later with: atris business add <slug>');
+      console.log('');
+      printFinished();
+      return;
+    }
+
+    businesses = Array.isArray(result.data) ? result.data : [];
+  } catch (err) {
+    console.error(`\n  Could not fetch businesses: ${err.message || err}`);
+    console.error('  You can add one later with: atris business add <slug>');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  if (businesses.length === 0) {
+    console.log('\n  No businesses found on your account.');
+    console.log('  Create one at https://atris.ai or ask your team admin for access.');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  // Step 4: List businesses and let user pick
+  console.log('');
+  console.log('  Your businesses:');
+  businesses.forEach((b, i) => {
+    const name = b.name || b.slug || 'Unnamed';
+    const slug = b.slug || b.id || '';
+    console.log(`    ${i + 1}. ${name} (${slug})`);
+  });
+  console.log('');
+
+  const answer = await promptUser('  Which business to pull? (number or slug, or "skip"): ');
+
+  if (!answer || answer.toLowerCase() === 'skip') {
+    console.log('  Skipped. You can pull a business later with: atris pull <slug>');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  // Resolve selection — try number first, then slug match
+  let selected = null;
+  const num = parseInt(answer, 10);
+  if (!isNaN(num) && num >= 1 && num <= businesses.length) {
+    selected = businesses[num - 1];
+  } else {
+    // Try slug or name match
+    const q = answer.toLowerCase();
+    selected = businesses.find(b => (b.slug || '').toLowerCase() === q)
+      || businesses.find(b => (b.name || '').toLowerCase() === q)
+      || businesses.find(b => (b.slug || '').toLowerCase().includes(q))
+      || businesses.find(b => (b.name || '').toLowerCase().includes(q));
+  }
+
+  if (!selected) {
+    console.error(`\n  Could not find a business matching "${answer}".`);
+    console.log('  Run "atris pull <slug>" to pull manually.');
+    console.log('');
+    printFinished();
+    return;
+  }
+
+  const slug = selected.slug || selected.id;
+  console.log(`\n  [4/4] Pulling "${selected.name || slug}"...`);
+
+  try {
+    const { pullAtris } = require('./pull');
+    // Set the arg so pullAtris picks it up
+    const originalArgv = process.argv.slice();
+    process.argv[3] = slug;
+    const originalExit = process.exit;
+    process.exit = (code) => {
+      if (code === 0) return;
+      originalExit(code);
+    };
+    try {
+      await pullAtris();
+    } finally {
+      process.exit = originalExit;
+      process.argv = originalArgv;
+    }
+    console.log(`  Pulled "${selected.name || slug}" ... OK`);
+  } catch (err) {
+    console.error(`\n  Pull failed: ${err.message || err}`);
+    console.log(`  You can try again with: atris pull ${slug}`);
+  }
+
+  console.log('');
+  printFinished();
+}
+
+function printFinished() {
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  You\'re all set! Run `atris activate` to start.');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+}
+
+module.exports = { setupAtris };

package/commands/workspace-clean.js

@@ -0,0 +1,249 @@
+const { loadCredentials } = require('../utils/auth');
+const { apiRequestJson } = require('../utils/api');
+const { loadBusinesses, saveBusinesses } = require('./business');
+
+// Junk detection patterns
+const JUNK_PATTERNS = {
+  emptyFiles: (file) => (file.size || 0) <= 1,
+  versionedDuplicates: (file) => /_v\d+\.\w+$/.test(file.path),
+  actionQueues: (file) => /action_queue\.json$/.test(file.path),
+  agentOutputDumps: (file) => /^\/?(agents\/[^/]+\/output\/)/.test(file.path),
+  researchDumps: (file) => /^\/?(agents\/[^/]+\/research\/)/.test(file.path),
+};
+
+const JUNK_LABELS = {
+  emptyFiles: 'Empty files (size <= 1 byte)',
+  versionedDuplicates: 'Versioned duplicates (*_v1, *_v2, etc.)',
+  actionQueues: 'Action queue files',
+  agentOutputDumps: 'Agent output dumps (agents/*/output/)',
+  researchDumps: 'Research dumps (agents/*/research/)',
+};
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}
+
+async function cleanWorkspace() {
+  const slug = process.argv[3];
+  const autoConfirm = process.argv.includes('--yes');
+
+  if (!slug || slug === '--help') {
+    console.log('');
+    console.log('Usage: atris clean-workspace <business-slug> [--yes]');
+    console.log('');
+    console.log('Analyzes a workspace for junk files and shows a cleanup report.');
+    console.log('Pass --yes to actually delete the detected junk.');
+    console.log('');
+    console.log('Detects:');
+    console.log('  - Empty files (0-1 bytes)');
+    console.log('  - Versioned duplicates (*_v1.md, *_v2.md, etc.)');
+    console.log('  - action_queue.json files');
+    console.log('  - Agent output dumps (agents/*/output/)');
+    console.log('  - Research dumps (agents/*/research/)');
+    console.log('');
+    return;
+  }
+
+  // Auth
+  const creds = loadCredentials();
+  if (!creds || !creds.token) {
+    console.error('Not logged in. Run: atris login');
+    process.exit(1);
+  }
+
+  // Resolve business
+  let businessId, workspaceId, businessName;
+  const businesses = loadBusinesses();
+
+  if (businesses[slug]) {
+    businessId = businesses[slug].business_id;
+    workspaceId = businesses[slug].workspace_id;
+    businessName = businesses[slug].name || slug;
+  } else {
+    const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+    if (!listResult.ok) {
+      console.error(`Failed to fetch businesses: ${listResult.error || listResult.status}`);
+      process.exit(1);
+    }
+    const match = (listResult.data || []).find(
+      b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
+    );
+    if (!match) {
+      console.error(`Business "${slug}" not found.`);
+      process.exit(1);
+    }
+    businessId = match.id;
+    workspaceId = match.workspace_id;
+    businessName = match.name;
+
+    // Cache for next time
+    businesses[slug] = {
+      business_id: businessId,
+      workspace_id: workspaceId,
+      name: businessName,
+      slug: match.slug,
+      added_at: new Date().toISOString(),
+    };
+    saveBusinesses(businesses);
+  }
+
+  if (!workspaceId) {
+    console.error(`Business "${slug}" has no workspace.`);
+    process.exit(1);
+  }
+
+  // Fetch snapshot (metadata only)
+  console.log('');
+  console.log(`Scanning ${businessName}...`);
+
+  const result = await apiRequestJson(
+    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=false`,
+    { method: 'GET', token: creds.token, timeoutMs: 60000 }
+  );
+
+  if (!result.ok) {
+    const msg = result.error || `HTTP ${result.status}`;
+    if (result.status === 409) {
+      console.error('\n  Computer is sleeping. Wake it first.');
+    } else if (result.status === 403) {
+      console.error(`\n  Access denied for "${slug}".`);
+    } else if (result.status === 404) {
+      console.error(`\n  Business "${slug}" not found.`);
+    } else {
+      console.error(`\n  Failed: ${msg}`);
+    }
+    process.exit(1);
+  }
+
+  const files = result.data.files || [];
+  if (files.length === 0) {
+    console.log('  Workspace is empty. Nothing to clean.');
+    return;
+  }
+
+  // Analyze workspace
+  const totalSize = files.reduce((sum, f) => sum + (f.size || 0), 0);
+
+  // Directory breakdown
+  const dirStats = {};
+  for (const file of files) {
+    const p = (file.path || '').replace(/^\//, '');
+    const topDir = p.includes('/') ? p.split('/')[0] : '(root)';
+    if (!dirStats[topDir]) dirStats[topDir] = { count: 0, size: 0 };
+    dirStats[topDir].count++;
+    dirStats[topDir].size += file.size || 0;
+  }
+
+  // Detect junk
+  const junkByCategory = {};
+  const allJunkPaths = new Set();
+
+  for (const [key, testFn] of Object.entries(JUNK_PATTERNS)) {
+    const matches = files.filter(testFn);
+    if (matches.length > 0) {
+      junkByCategory[key] = matches;
+      for (const m of matches) allJunkPaths.add(m.path);
+    }
+  }
+
+  const junkSize = files
+    .filter(f => allJunkPaths.has(f.path))
+    .reduce((sum, f) => sum + (f.size || 0), 0);
+
+  // Print report
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(`  Workspace: ${businessName}`);
+  console.log(`  Total files: ${files.length}    Total size: ${formatBytes(totalSize)}`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+  // Directory breakdown
+  console.log('');
+  console.log('  Files by directory:');
+  const sortedDirs = Object.entries(dirStats).sort((a, b) => b[1].size - a[1].size);
+  for (const [dir, stats] of sortedDirs) {
+    const pct = totalSize > 0 ? ((stats.size / totalSize) * 100).toFixed(0) : 0;
+    console.log(`    ${dir.padEnd(30)} ${String(stats.count).padStart(5)} files  ${formatBytes(stats.size).padStart(10)}  (${pct}%)`);
+  }
+
+  // Junk report
+  console.log('');
+  if (allJunkPaths.size === 0) {
+    console.log('  No junk detected. Workspace is clean.');
+    console.log('');
+    return;
+  }
+
+  console.log('  Junk detected:');
+  console.log('');
+
+  for (const [key, matches] of Object.entries(junkByCategory)) {
+    const catSize = matches.reduce((sum, f) => sum + (f.size || 0), 0);
+    console.log(`    ${JUNK_LABELS[key]}  (${matches.length} files, ${formatBytes(catSize)})`);
+
+    // Show up to 10 example paths
+    const show = matches.slice(0, 10);
+    for (const f of show) {
+      console.log(`      - ${(f.path || '').replace(/^\//, '')}  (${formatBytes(f.size || 0)})`);
+    }
+    if (matches.length > 10) {
+      console.log(`      ... and ${matches.length - 10} more`);
+    }
+    console.log('');
+  }
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(`  Would remove: ${allJunkPaths.size} files (${formatBytes(junkSize)})`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  if (!autoConfirm) {
+    console.log('  Run with --yes to clean up:');
+    console.log(`    atris clean-workspace ${slug} --yes`);
+    console.log('');
+    return;
+  }
+
+  // Delete junk by syncing empty content
+  console.log('  Cleaning...');
+
+  const filesToDelete = Array.from(allJunkPaths).map(p => ({ path: p, content: '' }));
+
+  // Batch in chunks of 50 to avoid huge payloads
+  const BATCH_SIZE = 50;
+  let deleted = 0;
+
+  for (let i = 0; i < filesToDelete.length; i += BATCH_SIZE) {
+    const batch = filesToDelete.slice(i, i + BATCH_SIZE);
+
+    const syncResult = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
+      {
+        method: 'POST',
+        token: creds.token,
+        body: { files: batch },
+        headers: { 'X-Atris-Actor-Source': 'cli' },
+      }
+    );
+
+    if (!syncResult.ok) {
+      const msg = syncResult.error || `HTTP ${syncResult.status}`;
+      console.error(`\n  Cleanup failed at batch ${Math.floor(i / BATCH_SIZE) + 1}: ${msg}`);
+      process.exit(1);
+    }
+
+    deleted += batch.length;
+    if (filesToDelete.length > BATCH_SIZE) {
+      console.log(`    ${deleted}/${filesToDelete.length} files processed...`);
+    }
+  }
+
+  console.log('');
+  console.log(`  Done. Removed ${deleted} junk files (${formatBytes(junkSize)}).`);
+  console.log('');
+}
+
+module.exports = { cleanWorkspace };

package/lib/manifest.js

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -82,9 +83,10 @@ function computeLocalHashes(localDir) {
       } else if (entry.isFile()) {
         const relPath = '/' + path.relative(localDir, fullPath);
         try {
-          const content = fs.readFileSync(fullPath, 'utf8');
-          const hash = computeFileHash(content);
-          files[relPath] = { hash, size: Buffer.byteLength(content) };
+          // Hash raw bytes to match warm runner's _hash_bytes(data)
+          const rawBytes = fs.readFileSync(fullPath);
+          const hash = crypto.createHash('sha256').update(rawBytes).digest('hex');
+          files[relPath] = { hash, size: rawBytes.length };
         } catch {
           // skip binary or unreadable
         }

package/lib/section-merge.js

@@ -0,0 +1,196 @@
+/**
+ * Section-level three-way merge for structured markdown files.
+ *
+ * Parses markdown into sections (split on ## headers + YAML frontmatter).
+ * Merges non-conflicting section changes. Flags same-section conflicts.
+ *
+ * This is what makes us better than git for context files.
+ * Git merges by line. We merge by section.
+ */
+
+/**
+ * Parse a markdown document into sections.
+ * Returns: { __frontmatter__: string, __header__: string, sections: [{name, content}] }
+ */
+function parseSections(content) {
+  if (!content) return { frontmatter: '', header: '', sections: [] };
+
+  const lines = content.split('\n');
+  let frontmatter = '';
+  let header = '';
+  const sections = [];
+  let current = null;
+  let inFrontmatter = false;
+  let frontmatterDone = false;
+  let headerLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // YAML frontmatter
+    if (i === 0 && line.trim() === '---') {
+      inFrontmatter = true;
+      headerLines.push(line);
+      continue;
+    }
+    if (inFrontmatter) {
+      headerLines.push(line);
+      if (line.trim() === '---') {
+        inFrontmatter = false;
+        frontmatterDone = true;
+        frontmatter = headerLines.join('\n');
+        headerLines = [];
+      }
+      continue;
+    }
+
+    // Section headers
+    if (line.startsWith('## ')) {
+      // Save previous section or header
+      if (current) {
+        sections.push(current);
+      } else if (headerLines.length > 0) {
+        header = headerLines.join('\n');
+      }
+      current = { name: line.substring(3).trim(), content: line };
+      continue;
+    }
+
+    // Content belongs to current section or header
+    if (current) {
+      current.content += '\n' + line;
+    } else {
+      headerLines.push(line);
+    }
+  }
+
+  // Save last section or header
+  if (current) {
+    sections.push(current);
+  } else if (headerLines.length > 0 && !header) {
+    header = headerLines.join('\n');
+  }
+
+  return { frontmatter, header, sections };
+}
+
+/**
+ * Reconstruct a markdown document from parsed sections.
+ */
+function reconstructDocument(parsed) {
+  const parts = [];
+  if (parsed.frontmatter) parts.push(parsed.frontmatter);
+  if (parsed.header) parts.push(parsed.header);
+  for (const section of parsed.sections) {
+    parts.push(section.content);
+  }
+  return parts.join('\n');
+}
+
+/**
+ * Three-way section merge.
+ *
+ * @param {string} base - Common ancestor content
+ * @param {string} local - Your version
+ * @param {string} remote - Their version
+ * @returns {{ merged: string|null, conflicts: [{section, local, remote}] }}
+ *
+ * If merged is non-null, the merge succeeded (conflicts array is empty).
+ * If merged is null, there are conflicts that need manual resolution.
+ */
+function sectionMerge(base, local, remote) {
+  const baseParsed = parseSections(base);
+  const localParsed = parseSections(local);
+  const remoteParsed = parseSections(remote);
+
+  const conflicts = [];
+
+  // Merge frontmatter (field-by-field if both changed, otherwise take the changed one)
+  let mergedFrontmatter = baseParsed.frontmatter;
+  if (localParsed.frontmatter !== baseParsed.frontmatter && remoteParsed.frontmatter === baseParsed.frontmatter) {
+    mergedFrontmatter = localParsed.frontmatter;
+  } else if (remoteParsed.frontmatter !== baseParsed.frontmatter && localParsed.frontmatter === baseParsed.frontmatter) {
+    mergedFrontmatter = remoteParsed.frontmatter;
+  } else if (localParsed.frontmatter !== remoteParsed.frontmatter && localParsed.frontmatter !== baseParsed.frontmatter) {
+    conflicts.push({ section: 'frontmatter', local: localParsed.frontmatter, remote: remoteParsed.frontmatter });
+  }
+
+  // Merge header
+  let mergedHeader = baseParsed.header;
+  if (localParsed.header !== baseParsed.header && remoteParsed.header === baseParsed.header) {
+    mergedHeader = localParsed.header;
+  } else if (remoteParsed.header !== baseParsed.header && localParsed.header === baseParsed.header) {
+    mergedHeader = remoteParsed.header;
+  } else if (localParsed.header !== remoteParsed.header && localParsed.header !== baseParsed.header) {
+    conflicts.push({ section: 'header', local: localParsed.header, remote: remoteParsed.header });
+  }
+
+  // Build section maps
+  const baseMap = {};
+  for (const s of baseParsed.sections) baseMap[s.name] = s.content;
+  const localMap = {};
+  for (const s of localParsed.sections) localMap[s.name] = s.content;
+  const remoteMap = {};
+  for (const s of remoteParsed.sections) remoteMap[s.name] = s.content;
+
+  // Get all section names preserving order (base order, then new sections)
+  const allNames = [];
+  const seen = new Set();
+  for (const s of baseParsed.sections) { allNames.push(s.name); seen.add(s.name); }
+  for (const s of localParsed.sections) { if (!seen.has(s.name)) { allNames.push(s.name); seen.add(s.name); } }
+  for (const s of remoteParsed.sections) { if (!seen.has(s.name)) { allNames.push(s.name); seen.add(s.name); } }
+
+  // Merge each section
+  const mergedSections = [];
+  for (const name of allNames) {
+    const b = baseMap[name] || null;
+    const l = localMap[name] || null;
+    const r = remoteMap[name] || null;
+
+    if (l === r) {
+      // Both same — take either (or null = both deleted)
+      if (l !== null) mergedSections.push({ name, content: l });
+      continue;
+    }
+
+    if (b === null) {
+      // New section — exists in one or both
+      if (l && !r) { mergedSections.push({ name, content: l }); continue; }
+      if (r && !l) { mergedSections.push({ name, content: r }); continue; }
+      // Both added same-named section with different content
+      conflicts.push({ section: name, local: l, remote: r });
+      mergedSections.push({ name, content: l }); // default to local
+      continue;
+    }
+
+    const localChanged = l !== b;
+    const remoteChanged = r !== b;
+
+    if (!localChanged && remoteChanged) {
+      if (r !== null) mergedSections.push({ name, content: r });
+      // else: remote deleted it, local didn't change → accept deletion
+    } else if (localChanged && !remoteChanged) {
+      if (l !== null) mergedSections.push({ name, content: l });
+      // else: local deleted it, remote didn't change → accept deletion
+    } else {
+      // Both changed the same section → conflict
+      conflicts.push({ section: name, local: l, remote: r });
+      if (l !== null) mergedSections.push({ name, content: l }); // default to local
+    }
+  }
+
+  if (conflicts.length > 0) {
+    return { merged: null, conflicts };
+  }
+
+  // Reconstruct
+  const merged = reconstructDocument({
+    frontmatter: mergedFrontmatter,
+    header: mergedHeader,
+    sections: mergedSections,
+  });
+
+  return { merged, conflicts: [] };
+}
+
+module.exports = { parseSections, reconstructDocument, sectionMerge };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "atrisDev (atris dev) - CLI for AI coding agents. Works with Claude Code, Cursor, Windsurf. Make any codebase AI-navigable.",
   "main": "bin/atris.js",
   "bin": {

package/utils/api.js

@@ -41,7 +41,7 @@ function httpRequest(urlString, options) {
     const parsed = new URL(urlString);
     const isHttps = parsed.protocol === 'https:';
     const transport = isHttps ? https : http;
-    const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 10000;
+    const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 30000;
 
     const requestOptions = {
       method: options.method || 'GET',
@@ -52,6 +52,13 @@ function httpRequest(urlString, options) {
     };
 
     const req = transport.request(requestOptions, (res) => {
+      // Follow redirects (301, 302, 307, 308)
+      if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
+        const redirectUrl = new URL(res.headers.location, urlString).toString();
+        resolve(httpRequest(redirectUrl, options));
+        return;
+      }
+
       const chunks = [];
       res.on('data', (chunk) => chunks.push(chunk));
       res.on('end', () => {
@@ -111,6 +118,7 @@ async function apiRequestJson(pathname, options = {}) {
       method: options.method || 'GET',
       headers,
       body: bodyPayload,
+      timeoutMs: options.timeoutMs,
     });
 
     const text = result.body.toString('utf8');

package/utils/update-check.js

@@ -4,8 +4,9 @@ const path = require('path');
 const os = require('os');
 
 const PACKAGE_NAME = 'atris';
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const CACHE_FILE = path.join(os.homedir(), '.atris-update-check.json');
+const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const ATRIS_DIR = path.join(os.homedir(), '.atris');
+const CACHE_FILE = path.join(ATRIS_DIR, '.update-check');
 
 function getInstalledVersion() {
   try {
@@ -34,6 +35,10 @@ function getCacheData() {
 
 function saveCacheData(latestVersion) {
   try {
+    // Ensure ~/.atris/ exists
+    if (!fs.existsSync(ATRIS_DIR)) {
+      fs.mkdirSync(ATRIS_DIR, { recursive: true });
+    }
     const data = {
       lastCheck: new Date().toISOString(),
       latestVersion: latestVersion,
@@ -164,15 +169,10 @@ async function checkForUpdates(force = false) {
 function showUpdateNotification(updateInfo) {
   if (!updateInfo || !updateInfo.needsUpdate) return;
 
-  console.log('');
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log(`📦 Update available: ${updateInfo.installed} → ${updateInfo.latest}`);
-  console.log(`   Run: npm update -g atris`);
-  if (updateInfo.fromCache) {
-    console.log(`   (checking npm registry...)`);
-  }
-  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-  console.log('');
+  // Single yellow warning line — non-intrusive
+  const yellow = '\x1b[33m';
+  const reset = '\x1b[0m';
+  console.log(`${yellow}Update available: ${updateInfo.installed} → ${updateInfo.latest}. Run: npm install -g atris${reset}`);
 }
 
 function autoUpdate(updateInfo) {