atris 3.15.0 → 3.15.12

package/commands/pull.js

@@ -11,6 +11,13 @@ const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocal
 const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
 const { resolveSafeOutputDir } = require('../lib/workspace-safety');
+const {
+  buildConflictReviewPacket,
+  readBaseContent,
+  removeBaseContents,
+  writeBaseContents,
+  writeConflictReviewPacket,
+} = require('../lib/company-brain-sync');
 
 function pruneEmptyParentDirs(filePath, stopDir) {
   let current = path.dirname(filePath);
@@ -26,11 +33,50 @@ function pruneEmptyParentDirs(filePath, stopDir) {
   }
 }
 
+function isBusinessWorkspaceRoot(dir) {
+  return fs.existsSync(path.join(dir, '.atris', 'business.json')) && fs.existsSync(path.join(dir, 'atris'));
+}
+
+function syncTimestamp() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function buildPullConflictReviewPacket(outputDir, conflictChanges, remoteContents = {}, timestamp = syncTimestamp()) {
+  const baseContents = {};
+  const localContents = {};
+  const normalizedRemoteContents = {};
+
+  for (const change of conflictChanges) {
+    const p = change.path;
+    const localPath = path.join(outputDir, p.replace(/^\//, ''));
+    try {
+      localContents[p] = fs.readFileSync(localPath, 'utf8');
+    } catch {
+      localContents[p] = '';
+    }
+
+    const baseContent = readBaseContent(outputDir, p);
+    if (baseContent !== null) baseContents[p] = baseContent;
+
+    normalizedRemoteContents[p] = Object.prototype.hasOwnProperty.call(remoteContents, p)
+      ? remoteContents[p]
+      : '';
+  }
+
+  return buildConflictReviewPacket({
+    plan: { changes: conflictChanges },
+    baseContents,
+    localContents,
+    remoteContents: normalizedRemoteContents,
+    timestamp,
+  });
+}
+
 async function pullAtris() {
   let arg = process.argv[3];
 
   if (arg === '--help') {
-    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>]');
+    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>] [--dry-run] [--no-manifest]');
     console.log('');
     console.log('  Pull is force-overwrite by default. Cloud is the source of truth.');
     console.log('  Local files that conflict with cloud are replaced by the cloud version.');
@@ -40,6 +86,8 @@ async function pullAtris() {
     console.log('  atris pull doordash --into /tmp/doordash');
     console.log('  atris pull doordash --only atris/wiki/');
     console.log('  atris pull --keep-local      Preserve conflicting local edits as .remote files (legacy)');
+    console.log('  atris pull --dry-run         Preview pull changes without writing local files');
+    console.log('  atris pull --no-manifest     Pull for inspection without changing this machine\'s sync anchor');
     return;
   }
 
@@ -127,6 +175,9 @@ async function pullBusiness(slug) {
   // --keep-local opts back into the legacy three-way merge with .remote conflict files.
   // --force is still accepted as an alias for the default for muscle-memory.
   const force = !process.argv.includes('--keep-local');
+  const failOnConflict = process.argv.includes('--fail-on-conflict');
+  const dryRun = process.argv.includes('--dry-run');
+  const noManifest = process.argv.includes('--no-manifest');
 
   // Parse --only flag: comma-separated directory prefixes to filter
   // Supports both --only=team/,context/ and --only team/,context/
@@ -140,7 +191,7 @@ async function pullBusiness(slug) {
       onlyRaw = process.argv[onlyIdx + 1];
     }
   }
-  const onlyPrefixes = onlyRaw
+  let onlyPrefixes = onlyRaw
     ? onlyRaw.split(',').map(p => {
         let norm = p.replace(/^\//, '');
         const wikiPrefix = normalizeWikiOnlyPrefix(norm);
@@ -202,6 +253,10 @@ async function pullBusiness(slug) {
   // for a stray cwd to cause atris to delete user files.
   ({ dir: outputDir } = resolveSafeOutputDir(outputDir, { slug, op: 'pull into' }));
 
+  if (!onlyPrefixes && isBusinessWorkspaceRoot(outputDir)) {
+    onlyPrefixes = ['atris/'];
+  }
+
   // Resolve business ID — always refresh from API to avoid stale workspace_id
   let businessId, workspaceId, businessName, resolvedSlug;
   let localSlug = slug;
@@ -283,6 +338,14 @@ async function pullBusiness(slug) {
   // Load manifest (last sync state)
   const manifest = loadManifest(resolvedSlug || slug);
   const timeSince = manifest ? _timeSince(manifest.last_sync) : null;
+  const localFilesBeforePull = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
+  const manifestRootMatchesOutput = !manifest || !manifest.workspace_root || (() => {
+    try {
+      return fs.realpathSync(manifest.workspace_root) === fs.realpathSync(outputDir);
+    } catch {
+      return path.resolve(manifest.workspace_root || '') === path.resolve(outputDir);
+    }
+  })();
 
   console.log('');
   console.log(`Pulling ${businessName}...` + (timeSince ? `  (last synced ${timeSince})` : ''));
@@ -297,7 +360,12 @@ async function pullBusiness(slug) {
   }, 250);
 
   // Smart pull: if we have a manifest (not first sync), fetch hashes first, then only changed content
-  const hasManifest = manifest && manifest.files && Object.keys(manifest.files).length > 0 && !force;
+  const hasManifest = manifest
+    && manifest.files
+    && Object.keys(manifest.files).length > 0
+    && Object.keys(localFilesBeforePull).length > 0
+    && manifestRootMatchesOutput
+    && !force;
   let result;
 
   const pathsParam = onlyPrefixes ? `&paths=${encodeURIComponent(onlyPrefixes.map(p => p.replace(/\/$/, '')).join(','))}` : '';
@@ -419,6 +487,19 @@ async function pullBusiness(slug) {
   let files = result.data.files || [];
   if (files.length === 0) {
     console.log('  Workspace is empty.');
+    const inScopeLocalBeforePull = Object.keys(localFilesBeforePull).filter((p) => {
+      if (!onlyPrefixes) return true;
+      const rel = p.replace(/^\//, '');
+      return onlyPrefixes.some((pref) => rel.startsWith(pref));
+    }).length;
+    if (!force && inScopeLocalBeforePull > 0) {
+      console.error('');
+      console.error('  Pull stopped: cloud returned zero files while local has in-scope content.');
+      console.error('  This usually means the snapshot endpoint is unhealthy or still warming.');
+      console.error('  No local files or sync manifest were changed.');
+      await emit('status_unknown', { error_detail: 'empty snapshot with local in-scope content' });
+      process.exit(1);
+    }
     // Don't early-return in force mode: we still need to fall through to the
     // mirror sweep so a genuinely-emptied cloud can clear local files. The
     // sweep itself has a safety guard that refuses to wipe local content
@@ -483,7 +564,7 @@ async function pullBusiness(slug) {
   }
 
   // Compute local file hashes
-  const localFiles = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
+  const localFiles = localFilesBeforePull;
 
   // 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;
@@ -491,11 +572,38 @@ async function pullBusiness(slug) {
   // Three-way compare
   const diff = threeWayCompare(localFiles, remoteFiles, effectiveManifest);
 
+  if (dryRun) {
+    console.log('');
+    for (const p of [...diff.toPull, ...diff.newRemote]) {
+      const label = diff.newRemote.includes(p) ? 'new on computer' : 'updated on computer';
+      const icon = diff.newRemote.includes(p) ? '+' : '\u2193';
+      console.log(`  ${icon} ${p.replace(/^\//, '')}  ${label}  (dry run)`);
+    }
+    for (const p of diff.conflicts) {
+      console.log(`  ! ${p.replace(/^\//, '')}  conflict  (dry run)`);
+    }
+    for (const p of diff.deletedRemote) {
+      console.log(`  - ${p.replace(/^\//, '')}  deleted on computer  (dry run)`);
+    }
+
+    const parts = [];
+    const pullCount = diff.toPull.length + diff.newRemote.length;
+    if (pullCount > 0) parts.push(`${pullCount} would be pulled`);
+    if (diff.deletedRemote.length > 0) parts.push(`${diff.deletedRemote.length} local file${diff.deletedRemote.length === 1 ? '' : 's'} would be removed`);
+    if (diff.unchanged.length > 0) parts.push(`${diff.unchanged.length} unchanged`);
+    if (diff.conflicts.length > 0) parts.push(`${diff.conflicts.length} conflict${diff.conflicts.length === 1 ? '' : 's'}`);
+    if (parts.length === 0) parts.push('no changes');
+    console.log(`\n  ${parts.join(', ')}. (--dry-run, nothing written)\n`);
+    return;
+  }
+
   // Apply changes
   let pulled = 0;
   let deleted = 0;
   let conflictCount = 0;
   let unchangedCount = diff.unchanged.length;
+  const conflictChanges = [];
+  const conflictRemoteContents = {};
 
   console.log('');
 
@@ -526,6 +634,8 @@ async function pullBusiness(slug) {
     } else {
       // Save remote version alongside local
       const content = remoteContent[p];
+      conflictRemoteContents[p] = content || '';
+      conflictChanges.push({ path: p, status: 'conflict_updated', action: 'review' });
       if (content || content === '') {
         const localPath = path.join(outputDir, p.replace(/^\//, '') + '.remote');
         fs.mkdirSync(path.dirname(localPath), { recursive: true });
@@ -553,6 +663,8 @@ async function pullBusiness(slug) {
       deleted++;
     } else {
       console.log(`  \u26A0 ${p.replace(/^\//, '')}  deleted on computer, but you changed it locally`);
+      conflictRemoteContents[p] = '';
+      conflictChanges.push({ path: p, status: 'conflict_remote_deleted_local_updated', action: 'review' });
       conflictCount++;
     }
   }
@@ -640,6 +752,22 @@ async function pullBusiness(slug) {
   if (unchangedCount > 0) parts.push(`${unchangedCount} unchanged`);
   if (conflictCount > 0) parts.push(`${conflictCount} conflict${conflictCount > 1 ? 's' : ''}`);
   if (parts.length > 0) console.log(`  ${parts.join(', ')}.`);
+  if (failOnConflict && conflictCount > 0) {
+    const timestamp = syncTimestamp();
+    const packet = buildPullConflictReviewPacket(outputDir, conflictChanges, conflictRemoteContents, timestamp);
+    writeConflictReviewPacket(outputDir, packet);
+    console.log('');
+    console.log(`  Sync paused: ${conflictCount} conflict${conflictCount === 1 ? '' : 's'} need review before publishing.`);
+    console.log(`  Review packet: .atris/sync/conflicts/${timestamp}/summary.md`);
+    console.log('  Resolve the conflict, then run sync again.');
+    process.exit(2);
+  }
+  if (remoteFiles['atris/now.md'] || remoteFiles['/atris/now.md']) {
+    const nowLocal = path.join(outputDir, 'atris', 'now.md');
+    if (fs.existsSync(nowLocal)) {
+      console.log('  now: atris/now.md is current.');
+    }
+  }
 
   // Get current commit hash from remote (for manifest)
   let commitHash = null;
@@ -693,10 +821,16 @@ async function pullBusiness(slug) {
     }
     manifestFiles = merged;
   }
-  const newManifest = buildManifest(manifestFiles, commitHash);
-  saveManifest(resolvedSlug || slug, newManifest);
+  if (!noManifest) {
+    const newManifest = buildManifest(manifestFiles, commitHash, { workspaceRoot: outputDir });
+    saveManifest(resolvedSlug || slug, newManifest);
+    writeBaseContents(outputDir, remoteContent);
+    removeBaseContents(outputDir, diff.deletedRemote);
+  }
 
-  // Save business config in the output dir so push/status work without args
+  // Save business config in the output dir so push/status work without args.
+  // Inspection pulls should not re-bind the global sync anchor, but the pulled
+  // folder still benefits from a local business marker for navigation.
   const atrisDir = path.join(outputDir, '.atris');
   fs.mkdirSync(atrisDir, { recursive: true });
   fs.writeFileSync(path.join(atrisDir, 'business.json'), JSON.stringify({
@@ -901,4 +1035,4 @@ async function pullMemberJournal(token, agentId, memberName, memberDir) {
   return synced;
 }
 
-module.exports = { pullAtris };
+module.exports = { buildPullConflictReviewPacket, pullAtris };

package/commands/push.js

@@ -9,6 +9,92 @@ const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
 const { assertSafeWorkspaceRoot } = require('../lib/workspace-safety');
 
+function resolvePushSourceDir({ slug, argv = process.argv, cwd = process.cwd() }) {
+  const fromIdx = argv.indexOf('--from');
+  if (fromIdx !== -1 && argv[fromIdx + 1]) {
+    return path.resolve(cwd, argv[fromIdx + 1]);
+  }
+
+  if (fs.existsSync(path.join(cwd, '.atris', 'business.json'))) {
+    // A pulled business folder is the workspace root. Its cloud paths include
+    // the top-level `atris/` directory, so pushing from `<business>/atris`
+    // strips that prefix and makes a force push look like "delete atris/* and
+    // recreate everything at root". Keep the business folder itself as root.
+    return cwd;
+  }
+
+  const atrisDir = path.join(cwd, 'atris', slug);
+  const cwdDir = path.join(cwd, slug);
+  if (fs.existsSync(atrisDir)) return atrisDir;
+  if (fs.existsSync(cwdDir)) return cwdDir;
+
+  return null;
+}
+
+function canonicalWorkspaceRoot(dir) {
+  try {
+    return fs.realpathSync(dir);
+  } catch {
+    return path.resolve(dir);
+  }
+}
+
+function basenameOfManifestPath(filePath) {
+  const cleaned = String(filePath || '').replace(/\/+$/, '');
+  const idx = cleaned.lastIndexOf('/');
+  return idx === -1 ? cleaned : cleaned.slice(idx + 1);
+}
+
+function isBusinessWorkspaceRoot(dir) {
+  return fs.existsSync(path.join(dir, '.atris', 'business.json')) && fs.existsSync(path.join(dir, 'atris'));
+}
+
+function pathInScope(filePath, onlyPrefixes) {
+  if (!onlyPrefixes) return true;
+  return onlyPrefixes.some(prefix => filePath.startsWith(prefix));
+}
+
+function buildPushChangePlan({
+  localFiles = {},
+  baseFiles = {},
+  onlyPrefixes = null,
+  readFileContent,
+} = {}) {
+  const filesToPush = [];
+  const deletedPaths = [];
+
+  for (const [filePath, fileInfo] of Object.entries(localFiles)) {
+    if (!pathInScope(filePath, onlyPrefixes)) continue;
+    const baseHash = baseFiles[filePath] ? baseFiles[filePath].hash : null;
+    if (!baseHash || fileInfo.hash !== baseHash) {
+      try {
+        const content = readFileContent ? readFileContent(filePath) : '';
+        filesToPush.push({ path: filePath, content });
+      } catch {
+        // File moved or became unreadable while planning; skip this cycle.
+      }
+    }
+  }
+
+  for (const filePath of Object.keys(baseFiles)) {
+    if (!pathInScope(filePath, onlyPrefixes)) continue;
+    if (basenameOfManifestPath(filePath).startsWith('.')) continue;
+    if (!localFiles[filePath]) {
+      deletedPaths.push(filePath);
+    }
+  }
+
+  const filteredLocalCount = Object.keys(localFiles).filter(filePath => pathInScope(filePath, onlyPrefixes)).length;
+  const unchangedCount = Math.max(0, filteredLocalCount - filesToPush.length);
+  return { filesToPush, deletedPaths, unchangedCount };
+}
+
+function shouldRetrySyncIndividually(result, filesToPush) {
+  if (!result || result.ok) return false;
+  if (!Array.isArray(filesToPush) || filesToPush.length <= 1) return false;
+  return result.status !== 403 && result.status !== 409;
+}
+
 async function pushAtris() {
   const elapsedMs = startTimer();
   let slug = process.argv[3];
@@ -27,7 +113,7 @@ async function pushAtris() {
   }
 
   if (!slug || slug === '--help') {
-    console.log('Usage: atris push [business] [--from <path>] [--only <prefix>] [--force]');
+    console.log('Usage: atris push [business] [--from <path>] [--only <prefix>] [--force] [--delete]');
     console.log('');
     console.log('  Push requires a fresh pull. If cloud has changed since your last pull,');
     console.log('  the push will be blocked until you run `atris pull`. Use --force to override.');
@@ -36,11 +122,14 @@ async function pushAtris() {
     console.log('  atris push pallet            Push pallet/ or atris/pallet/');
     console.log('  atris push pallet --only team/nate   Only push files in team/nate/');
     console.log('  atris push --force           Bypass freshness check (force-push, may overwrite cloud changes)');
+    console.log('  atris push --delete          Allow cloud deletes shown by --dry-run');
     process.exit(0);
   }
 
   const force = process.argv.includes('--force');
   const dryRun = process.argv.includes('--dry-run');
+  const allowDelete = process.argv.includes('--delete');
+  const allowCrossRootManifest = process.argv.includes('--allow-cross-root-manifest');
 
   // Parse --only
   let onlyRaw = null;
@@ -50,7 +139,7 @@ async function pushAtris() {
     const oi = process.argv.indexOf('--only');
     if (oi !== -1 && process.argv[oi + 1] && !process.argv[oi + 1].startsWith('-')) onlyRaw = process.argv[oi + 1];
   }
-  const onlyPrefixes = onlyRaw
+  let onlyPrefixes = onlyRaw
     ? onlyRaw.split(',').map(p => {
         const wikiPrefix = normalizeWikiOnlyPrefix(p);
         if (wikiPrefix) return `/${wikiPrefix.replace(/^\//, '')}`;
@@ -64,22 +153,11 @@ async function pushAtris() {
   if (!creds || !creds.token) { console.error('Not logged in. Run: atris login'); process.exit(1); }
 
   // Determine source directory
-  const fromIdx = process.argv.indexOf('--from');
-  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'))) {
-    sourceDir = process.cwd();
-  } else {
-    const atrisDir = path.join(process.cwd(), 'atris', slug);
-    const cwdDir = path.join(process.cwd(), slug);
-    if (fs.existsSync(atrisDir)) sourceDir = atrisDir;
-    else if (fs.existsSync(cwdDir)) sourceDir = cwdDir;
-    else {
-      console.error(`No local folder found for "${slug}".`);
-      console.error('Run from inside a pulled folder, or: atris push pallet --from ./path');
-      process.exit(1);
-    }
+  const sourceDir = resolvePushSourceDir({ slug });
+  if (!sourceDir) {
+    console.error(`No local folder found for "${slug}".`);
+    console.error('Run from inside a pulled folder, or: atris push pallet --from ./path');
+    process.exit(1);
   }
 
   if (!fs.existsSync(sourceDir)) { console.error(`Source not found: ${sourceDir}`); process.exit(1); }
@@ -87,6 +165,10 @@ async function pushAtris() {
   // Refuse to walk/upload dangerous paths ($HOME, /, /Users, system dirs).
   assertSafeWorkspaceRoot(sourceDir, { slug, op: 'push from' });
 
+  if (!onlyPrefixes && isBusinessWorkspaceRoot(sourceDir)) {
+    onlyPrefixes = ['/atris/'];
+  }
+
   // Resolve business — always refresh from API
   let businessId, workspaceId, businessName, resolvedSlug;
   const businesses = loadBusinesses();
@@ -145,6 +227,24 @@ async function pushAtris() {
   const manifest = loadManifest(resolvedSlug || slug);
   const localFiles = computeLocalHashes(sourceDir);
 
+  if (manifest && manifest.workspace_root && !allowCrossRootManifest) {
+    const manifestRoot = canonicalWorkspaceRoot(manifest.workspace_root);
+    const currentRoot = canonicalWorkspaceRoot(sourceDir);
+    if (manifestRoot !== currentRoot) {
+      console.log('');
+      console.log('  ✗ This folder has not been pulled since the current sync manifest was created.');
+      console.log('');
+      console.log(`    Manifest folder: ${manifest.workspace_root}`);
+      console.log(`    Current folder:  ${sourceDir}`);
+      console.log('');
+      console.log('    To sync safely, run these from the folder you want to push:');
+      console.log(`      atris pull ${resolvedSlug || slug} --keep-local --timeout 120`);
+      console.log(`      atris push ${resolvedSlug || slug} --dry-run`);
+      console.log(`      atris push ${resolvedSlug || slug}`);
+      process.exit(1);
+    }
+  }
+
   if (Object.keys(localFiles).length === 0) {
     console.log(`\nNo files to push from ${sourceDir}`);
     return;
@@ -240,38 +340,16 @@ async function pushAtris() {
   // Compare local hashes to manifest — NO server call needed
   // Files where local hash differs from manifest = changed locally
   const baseFiles = (manifest && manifest.files) ? manifest.files : {};
-  const filesToPush = [];
-  const deletedPaths = [];
-
-  for (const [filePath, fileInfo] of Object.entries(localFiles)) {
-    if (onlyPrefixes && !onlyPrefixes.some(p => filePath.startsWith(p))) continue;
-    const baseHash = baseFiles[filePath] ? baseFiles[filePath].hash : null;
-    if (!baseHash || fileInfo.hash !== baseHash) {
-      // Changed or new — push it
-      const localPath = path.join(sourceDir, filePath.replace(/^\//, ''));
-      try {
-        const content = fs.readFileSync(localPath, 'utf8');
-        filesToPush.push({ path: filePath, content });
-      } catch {}
-    }
-  }
-
-  for (const filePath of Object.keys(baseFiles)) {
-    if (onlyPrefixes && !onlyPrefixes.some(p => filePath.startsWith(p))) continue;
-    if (!localFiles[filePath]) {
-      deletedPaths.push(filePath);
-    }
-  }
-
-  const filteredLocalCount = Object.keys(localFiles).filter(filePath => {
-    if (!onlyPrefixes) return true;
-    return onlyPrefixes.some(prefix => filePath.startsWith(prefix));
-  }).length;
-  const unchangedCount = Math.max(0, filteredLocalCount - filesToPush.length);
+  const { filesToPush, deletedPaths, unchangedCount } = buildPushChangePlan({
+    localFiles,
+    baseFiles,
+    onlyPrefixes,
+    readFileContent: (filePath) => fs.readFileSync(path.join(sourceDir, filePath.replace(/^\//, '')), 'utf8'),
+  });
 
   if (filesToPush.length === 0 && deletedPaths.length === 0) {
     console.log('\n  Already up to date.\n');
-    await emit('success', { files_unchanged: filteredLocalCount });
+    await emit('success', { files_unchanged: unchangedCount });
     return;
   }
 
@@ -290,9 +368,28 @@ async function pushAtris() {
     if (deletedPaths.length > 0) parts.push(`${deletedPaths.length} would be deleted`);
     if (unchangedCount > 0) parts.push(`${unchangedCount} unchanged`);
     console.log(`\n  ${parts.join(', ')}. (--dry-run, nothing sent)\n`);
+    if (deletedPaths.length > 0) {
+      console.log('  Deletes require an explicit real push with --delete.');
+      console.log('  If these deletes are unexpected, run `atris pull --keep-local` first.\n');
+    }
     return;
   }
 
+  if (deletedPaths.length > 0 && !allowDelete) {
+    console.log('');
+    console.log(`  ✗ Refusing to delete ${deletedPaths.length} cloud file${deletedPaths.length === 1 ? '' : 's'} without --delete.`);
+    console.log('');
+    console.log('    Preview first:');
+    console.log(`      atris push ${resolvedSlug || slug} --dry-run`);
+    console.log('');
+    console.log('    If the deletes are intentional:');
+    console.log(`      atris push ${resolvedSlug || slug} --delete`);
+    console.log('');
+    console.log('    If the deletes are surprising, pull cloud truth first:');
+    console.log(`      atris pull ${resolvedSlug || slug} --keep-local --timeout 120`);
+    process.exit(1);
+  }
+
   let pushed = 0;
   let deleted = 0;
   let skipped = [];
@@ -307,6 +404,7 @@ async function pushAtris() {
   let failedToLand = [];
   const landedPaths = new Set();
   let result = { ok: true };
+  let batchFailureDetail = null;
 
   // Server-canonical path format for the /sync endpoint: NO leading slash.
   // The warm runner's _safe_path rejects `/atris/...` with "Absolute path
@@ -319,6 +417,10 @@ async function pushAtris() {
     return s.startsWith('/') ? s : `/${s}`;
   };
   const wireFiles = (files) => files.map((f) => ({ path: toWirePath(f.path), content: f.content }));
+  const syncFiles = (files) => apiRequestJson(
+    `/business/${businessId}/workspaces/${workspaceId}/sync`,
+    { method: 'POST', token: creds.token, body: { files: wireFiles(files) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
+  );
 
   // Inspect per-file results from a /sync response. Treat "written" and
   // "unchanged" as success; everything else (including missing-from-results,
@@ -360,10 +462,7 @@ async function pushAtris() {
 
   if (filesToPush.length > 0) {
     // Push files to server (strip leading slash — server requires workspace-relative paths)
-    result = await apiRequestJson(
-      `/business/${businessId}/workspaces/${workspaceId}/sync`,
-      { method: 'POST', token: creds.token, body: { files: wireFiles(filesToPush) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
-    );
+    result = await syncFiles(filesToPush);
 
     if (!result.ok) {
       if (result.status === 403) {
@@ -378,10 +477,7 @@ async function pushAtris() {
         skipped = filesToPush.filter(f => !f.path.startsWith('/team/') && !f.path.startsWith('/journal/'));
 
         if (allowed.length > 0) {
-          const retry = await apiRequestJson(
-            `/business/${businessId}/workspaces/${workspaceId}/sync`,
-            { method: 'POST', token: creds.token, body: { files: wireFiles(allowed) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
-          );
+          const retry = await syncFiles(allowed);
           if (retry.ok) {
             recordSyncResults(allowed, retry);
             pushed = landedPaths.size;
@@ -399,6 +495,23 @@ async function pushAtris() {
         console.error('\n  Computer is sleeping. Wake it first.');
         await emit('cold_wake', { error_detail: 'computer sleeping (409)' });
         process.exit(1);
+      } else if (shouldRetrySyncIndividually(result, filesToPush)) {
+        batchFailureDetail = `${result.status || 'unknown'}: ${result.errorMessage || result.error || 'batch sync failed'}`;
+        console.log('');
+        console.log(`  Batch push failed (${result.errorMessage || result.error || result.status}). Retrying one file at a time...`);
+        for (const f of filesToPush) {
+          const single = await syncFiles([f]);
+          if (single.ok) {
+            recordSyncResults([f], single);
+          } else {
+            failedToLand.push({
+              path: f.path,
+              status: single.status || 'error',
+              error: single.errorMessage || single.error || '',
+            });
+          }
+        }
+        pushed = landedPaths.size;
       } else {
         console.error(`\n  Push failed: ${result.errorMessage || result.error || result.status}`);
         await emit('status_unknown', { error_detail: `sync status ${result.status}` });
@@ -526,7 +639,7 @@ async function pushAtris() {
   for (const filePath of deletedConfirmed) {
     delete updatedFiles[filePath];
   }
-  saveManifest(resolvedSlug || slug, buildManifest(updatedFiles, null));
+  saveManifest(resolvedSlug || slug, buildManifest(updatedFiles, null, { workspaceRoot: sourceDir }));
 
   // Telemetry — outcome reflects actual run quality, not just exit-code-zero.
   // Partial delete failures or rate-limit retries mean the run was NOT a clean win;
@@ -540,6 +653,9 @@ async function pushAtris() {
   } else if (deleteFailed.length > 0) {
     finalOutcome = 'status_unknown';
     finalDetail = `${deleteFailed.length} delete(s) failed (statuses: ${[...new Set(deleteFailed.map(f => f.status))].join(',')})`;
+  } else if (batchFailureDetail) {
+    finalOutcome = 'status_unknown';
+    finalDetail = `batch sync failed but individual retry landed all files (${batchFailureDetail})`;
   } else if (_rateLimitedDeletes > 0) {
     finalOutcome = 'rate_limited';
     finalDetail = `${_rateLimitedDeletes} delete(s) hit 429 (recovered)`;
@@ -558,4 +674,12 @@ async function pushAtris() {
   });
 }
 
-module.exports = { pushAtris };
+module.exports = {
+  pushAtris,
+  buildPushChangePlan,
+  shouldRetrySyncIndividually,
+  resolvePushSourceDir,
+  canonicalWorkspaceRoot,
+  basenameOfManifestPath,
+  isBusinessWorkspaceRoot,
+};