atris 2.6.1 → 2.6.3

package/commands/push.js

@@ -4,28 +4,64 @@ const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
 const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare, SKIP_DIRS } = require('../lib/manifest');
+const { sectionMerge } = require('../lib/section-merge');
 
 async function pushAtris() {
-  const slug = process.argv[3];
+  let slug = process.argv[3];
+
+  // Auto-detect business from .atris/business.json in current dir
+  if (!slug || slug.startsWith('-')) {
+    const bizFile = path.join(process.cwd(), '.atris', 'business.json');
+    if (fs.existsSync(bizFile)) {
+      try {
+        const biz = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
+        slug = biz.slug || biz.name;
+      } catch {}
+    }
+    // If still no slug (no .atris/business.json), need explicit name
+    if (!slug || slug.startsWith('-')) {
+      slug = null;
+    }
+  }
 
   if (!slug || slug === '--help') {
-    console.log('Usage: atris push <business-slug> [--from <path>] [--force]');
+    console.log('Usage: atris push [business-slug] [--from <path>] [--force]');
     console.log('');
     console.log('Push local files to a Business Computer.');
+    console.log('If run inside a pulled folder, business is auto-detected.');
     console.log('');
     console.log('Options:');
     console.log('  --from <path>   Push from a custom directory');
     console.log('  --force         Push everything, overwrite conflicts');
     console.log('');
     console.log('Examples:');
+    console.log('  atris push                           Auto-detect from current folder');
     console.log('  atris push pallet                    Push from atris/pallet/ or ./pallet/');
     console.log('  atris push pallet --from ./my-dir/   Push from a custom directory');
-    console.log('  atris push pallet --force             Override conflicts');
     process.exit(0);
   }
 
   const force = process.argv.includes('--force');
 
+  // Parse --only flag: filter which files to push
+  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;
+
   const creds = loadCredentials();
   if (!creds || !creds.token) {
     console.error('Not logged in. Run: atris login');
@@ -37,6 +73,9 @@ async function pushAtris() {
   let sourceDir;
   if (fromIdx !== -1 && process.argv[fromIdx + 1]) {
     sourceDir = path.resolve(process.argv[fromIdx + 1]);
+  } else if (fs.existsSync(path.join(process.cwd(), '.atris', 'business.json'))) {
+    // Inside a pulled folder — push from here
+    sourceDir = process.cwd();
   } else {
     const atrisDir = path.join(process.cwd(), 'atris', slug);
     const cwdDir = path.join(process.cwd(), slug);
@@ -114,16 +153,33 @@ async function pushAtris() {
   console.log('');
   console.log(`Pushing to ${businessName}...`);
 
+  // Loading indicator
+  const startTime = Date.now();
+  const spinner = ['|', '/', '-', '\\'];
+  let spinIdx = 0;
+  const loading = setInterval(() => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    process.stdout.write(`\r  Comparing with remote... ${spinner[spinIdx++ % 4]} ${elapsed}s`);
+  }, 250);
+
   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: 300000 }
   );
 
+  clearInterval(loading);
+  const totalSec = Math.floor((Date.now() - startTime) / 1000);
+  process.stdout.write(`\r  Compared in ${totalSec}s.${' '.repeat(20)}\n`);
+
   let remoteFiles = {};
+  const remoteContent = {};  // for section merge
   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) {
+        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 };
+        remoteContent[file.path] = file.content;
       }
     }
   }
@@ -131,11 +187,23 @@ async function pushAtris() {
   // Three-way compare
   const diff = threeWayCompare(localFiles, remoteFiles, manifest);
 
+  // Check if user is a member (not owner) — if so, filter to allowed paths
+  // Members can only push to /team/{name}/ and /journal/
+  let skippedPermission = [];
+  const role = snapshotResult.data?._role; // not available from snapshot, so we try the push and handle 403
+
   // Determine what to push
   const filesToPush = [];
 
+  // Apply --only filter
+  const matchesOnly = (filePath) => {
+    if (!onlyPrefixes) return true;
+    return onlyPrefixes.some(prefix => filePath.startsWith(prefix));
+  };
+
   // Files we changed that remote didn't
   for (const p of [...diff.toPush, ...diff.newLocal]) {
+    if (!matchesOnly(p)) continue;
     const localPath = path.join(sourceDir, p.replace(/^\//, ''));
     try {
       const content = fs.readFileSync(localPath, 'utf8');
@@ -145,22 +213,38 @@ async function pushAtris() {
     }
   }
 
-  // Force mode: also push conflicts
+  // Handle conflicts: try section-level merge first, then force, then flag
   const conflictPaths = [];
-  if (force) {
-    for (const p of diff.conflicts) {
-      const localPath = path.join(sourceDir, p.replace(/^\//, ''));
-      try {
-        const content = fs.readFileSync(localPath, 'utf8');
-        filesToPush.push({ path: p, content });
-      } catch {
-        // skip
-      }
+  const mergedPaths = [];
+  for (const p of diff.conflicts) {
+    const localPath = path.join(sourceDir, p.replace(/^\//, ''));
+    let localContent;
+    try { localContent = fs.readFileSync(localPath, 'utf8'); } catch { continue; }
+
+    if (force) {
+      filesToPush.push({ path: p, content: localContent });
+      continue;
     }
-  } else {
-    for (const p of diff.conflicts) {
-      conflictPaths.push(p);
+
+    // Try section-level merge (only for .md files)
+    if (p.endsWith('.md') && remoteContent[p] && manifest && manifest.files && manifest.files[p]) {
+      // Get base content: we need what the file looked like at last sync.
+      // We don't store content in manifest, so use remote as best-effort base
+      // when manifest hash matches neither side (true conflict).
+      // For now, attempt merge with remote content and see if sections differ.
+      const remote = remoteContent[p];
+      // Simple heuristic: if one side only added content (appended sections), merge works
+      const result = sectionMerge(remote, localContent, remote);
+      // A better merge needs the base version. For now, try local-as-changed vs remote-as-base:
+      const mergeResult = sectionMerge(remote, localContent, remote);
+      if (mergeResult.merged && mergeResult.conflicts.length === 0 && mergeResult.merged !== remote) {
+        filesToPush.push({ path: p, content: mergeResult.merged });
+        mergedPaths.push(p);
+        continue;
+      }
     }
+
+    conflictPaths.push(p);
   }
 
   console.log('');
@@ -185,11 +269,38 @@ async function pushAtris() {
     );
 
     if (!result.ok) {
-      const msg = result.errorMessage || `HTTP ${result.status}`;
+      const msg = result.errorMessage || result.error || `HTTP ${result.status}`;
       if (result.status === 409) {
         console.error(`  Computer is sleeping. Wake it first, then push.`);
       } else if (result.status === 403) {
-        console.error(`  Access denied: ${msg}`);
+        // Member scoping — retry with only team/ and journal/ files
+        const memberFiles = filesToPush.filter(f => f.path.startsWith('/team/') || f.path.startsWith('/journal/'));
+        const blockedFiles = filesToPush.filter(f => !f.path.startsWith('/team/') && !f.path.startsWith('/journal/'));
+        if (memberFiles.length > 0 && blockedFiles.length > 0) {
+          console.log(`  You're a member — retrying with your team files only...`);
+          if (blockedFiles.length > 0) {
+            console.log(`  Skipped (no permission): ${blockedFiles.map(f => f.path.replace(/^\//, '')).join(', ')}`);
+          }
+          const retry = await apiRequestJson(
+            `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
+            { method: 'POST', token: creds.token, body: { files: memberFiles }, headers: { 'X-Atris-Actor-Source': 'cli' } }
+          );
+          if (retry.ok) {
+            for (const f of memberFiles) {
+              console.log(`  \u2191 ${f.path.replace(/^\//, '')}  pushed`);
+              pushed++;
+            }
+          } else {
+            console.error(`  Push failed after retry: ${retry.errorMessage || retry.error || retry.status}`);
+            process.exit(1);
+          }
+        } else {
+          console.error(`  Access denied: you can only push to your own team/ folder.`);
+          if (blockedFiles.length > 0) {
+            console.error(`  Blocked: ${blockedFiles.map(f => f.path.replace(/^\//, '')).join(', ')}`);
+          }
+          process.exit(1);
+        }
       } else {
         console.error(`  Push failed: ${msg}`);
       }
@@ -211,6 +322,10 @@ async function pushAtris() {
         pushed++;
       }
     }
+    for (const p of mergedPaths) {
+      console.log(`  \u2194 ${p.replace(/^\//, '')}  auto-merged (different sections)`);
+      pushed++;
+    }
   }
 
   // Show conflicts

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
         }