atris 2.6.1 → 2.6.3

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

@@ -10,10 +10,23 @@ const { loadBusinesses } = require('./business');
 const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare } = require('../lib/manifest');
 
 async function pullAtris() {
-  const arg = process.argv[3];
+  let arg = process.argv[3];
+
+  // Auto-detect business from .atris/business.json in current dir
+  if (!arg || arg.startsWith('--')) {
+    const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+    if (fs.existsSync(bizFile)) {
+      try {
+        const biz = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
+        if (biz.slug || biz.name) {
+          return pullBusiness(biz.slug || biz.name);
+        }
+      } catch {}
+    }
+  }
 
   // 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 +93,40 @@ async function pullBusiness(slug) {
 
   const force = process.argv.includes('--force');
 
+  // Parse --only flag: comma-separated directory prefixes to filter
+  // Supports both --only=team/,context/ and --only team/,context/
+  let onlyRaw = null;
+  const onlyEqArg = process.argv.find(a => a.startsWith('--only='));
+  if (onlyEqArg) {
+    onlyRaw = onlyEqArg.slice('--only='.length);
+  } else {
+    const onlyIdx = process.argv.indexOf('--only');
+    if (onlyIdx !== -1 && process.argv[onlyIdx + 1] && !process.argv[onlyIdx + 1].startsWith('-')) {
+      onlyRaw = process.argv[onlyIdx + 1];
+    }
+  }
+  const onlyPrefixes = onlyRaw
+    ? onlyRaw.split(',').map(p => {
+        let norm = p.replace(/^\//, '');
+        if (norm && !norm.endsWith('/') && !norm.includes('.')) norm += '/';
+        return norm;
+      }).filter(Boolean)
+    : null;
+
+  // Parse --timeout flag: override default 300s timeout
+  // Supports both --timeout=60 and --timeout 60
+  let timeoutSec = 300;
+  const timeoutEqArg = process.argv.find(a => a.startsWith('--timeout='));
+  if (timeoutEqArg) {
+    timeoutSec = parseInt(timeoutEqArg.slice('--timeout='.length), 10);
+  } else {
+    const timeoutIdx = process.argv.indexOf('--timeout');
+    if (timeoutIdx !== -1 && process.argv[timeoutIdx + 1]) {
+      timeoutSec = parseInt(process.argv[timeoutIdx + 1], 10);
+    }
+  }
+  const timeoutMs = timeoutSec * 1000;
+
   // Determine output directory
   const intoIdx = process.argv.indexOf('--into');
   let outputDir;
@@ -94,21 +141,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 +170,7 @@ async function pullBusiness(slug) {
     businessName = match.name;
     resolvedSlug = match.slug;
 
+    // Update local cache
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
@@ -144,15 +194,31 @@ async function pullBusiness(slug) {
   console.log('');
   console.log(`Pulling ${businessName}...` + (timeSince ? `  (last synced ${timeSince})` : ''));
 
-  // 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 }
-  );
+  // Loading indicator with elapsed time
+  const startTime = Date.now();
+  const spinner = ['|', '/', '-', '\\'];
+  let spinIdx = 0;
+  const loading = setInterval(() => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    process.stdout.write(`\r  Fetching workspace... ${spinner[spinIdx++ % 4]} ${elapsed}s`);
+  }, 250);
+
+  // Get remote snapshot — pass --only prefixes to server for faster response
+  let snapshotUrl = `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=true`;
+  if (onlyPrefixes) {
+    snapshotUrl += `&paths=${encodeURIComponent(onlyPrefixes.map(p => p.replace(/\/$/, '')).join(','))}`;
+  }
+  const result = await apiRequestJson(snapshotUrl, { method: 'GET', token: creds.token, timeoutMs });
+
+  clearInterval(loading);
+  const totalSec = Math.floor((Date.now() - startTime) / 1000);
+  process.stdout.write(`\r  Fetched in ${totalSec}s.${' '.repeat(20)}\n`);
 
   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 timed out (large workspaces can take 60s+). Try: atris pull ${slug} --timeout=600`);
+    } 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,27 +230,50 @@ 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;
   }
 
   // Compute local file hashes
   const localFiles = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
 
+  // If output dir is empty (fresh clone) or --force, treat as first sync — pull everything
+  const effectiveManifest = (Object.keys(localFiles).length === 0 || force) ? null : manifest;
+
   // Three-way compare
-  const baseFiles = (manifest && manifest.files) ? manifest.files : {};
-  const diff = threeWayCompare(localFiles, remoteFiles, manifest);
+  const diff = threeWayCompare(localFiles, remoteFiles, effectiveManifest);
 
   // Apply changes
   let pulled = 0;
@@ -265,9 +354,23 @@ 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);
+
+  // Save business config in the output dir so push/status work without args
+  const atrisDir = path.join(outputDir, '.atris');
+  fs.mkdirSync(atrisDir, { recursive: true });
+  fs.writeFileSync(path.join(atrisDir, 'business.json'), JSON.stringify({
+    slug: resolvedSlug || slug,
+    business_id: businessId,
+    workspace_id: workspaceId,
+    name: businessName,
+  }, null, 2));
 }