pal-explorer-cli 0.4.12 → 0.4.13

package/lib/commands/sync.js

@@ -1,979 +1,979 @@
-import chalk from 'chalk';
-import path from 'path';
-import fs from 'fs';
-import config from '../utils/config.js';
-import logger from '../utils/logger.js';
-import { buildManifest as buildDiffManifest, diffManifests as diffFileManifests, diffSummary } from '../core/fileDiff.js';
-import { getFriends } from '../core/users.js';
-import {
-  buildManifest,
-  diffManifests,
-  manifestToMap,
-  detectConflicts,
-  applyDiff,
-  formatSize,
-  SyncSession,
-} from '../core/syncEngine.js';
-import {
-  getSyncPairs,
-  addSyncPair,
-  removeSyncPair,
-  updateSyncPair,
-  findSyncPair,
-  saveSyncManifest,
-  getSyncManifest,
-  getLastSyncedManifestMap,
-  addSyncHistoryEntry,
-  getSyncHistory,
-} from '../core/syncState.js';
-import { selectSyncTransport } from '../core/syncTransport.js';
-import { registerSyncHandlers } from '../core/syncProtocolHandlers.js';
-import { parseSyncOptions, addSyncFlagsToCommand } from '../core/syncOptions.js';
-
-function getIdentity() {
-  const identity = config.get('identity');
-  if (!identity?.handle) {
-    throw new Error('Not registered. Run `pe init` and `pe register` first.');
-  }
-  return identity;
-}
-
-function getKeyPair() {
-  const identity = config.get('identity');
-  if (!identity?.publicKey || !identity?.privateKey) {
-    throw new Error('Identity keys not configured. Run `pe init` first.');
-  }
-  return {
-    publicKey: Buffer.from(identity.publicKey, 'hex'),
-    secretKey: Buffer.from(identity.privateKey, 'hex'),
-  };
-}
-
-function findPal(palName) {
-  const friends = getFriends();
-  const pal = friends.find(f => f.name === palName || f.id === palName || f.handle === palName);
-  if (!pal) {
-    throw new Error(`Pal '${palName}' not found. Add them first with \`pe pal add\`.`);
-  }
-  return pal;
-}
-
-function validateDir(dirPath) {
-  const abs = path.resolve(dirPath);
-  if (!fs.existsSync(abs)) {
-    throw new Error(`Path not found: ${abs}`);
-  }
-  if (!fs.statSync(abs).isDirectory()) {
-    throw new Error('Sync only works with directories. Use `pe share` for single files.');
-  }
-  return abs;
-}
-
-function printDiffSummary(diff, verbose) {
-  if (diff.added.length) {
-    console.log(chalk.green(`    + ${diff.added.length} new file(s)`));
-    if (verbose) diff.added.forEach(a => console.log(chalk.green(`      + ${a.relativePath}`)));
-  }
-  if (diff.modified.length) {
-    console.log(chalk.yellow(`    ~ ${diff.modified.length} modified file(s)`));
-    if (verbose) diff.modified.forEach(m => console.log(chalk.yellow(`      ~ ${m.relativePath}`)));
-  }
-  if (diff.deleted.length) {
-    console.log(chalk.red(`    - ${diff.deleted.length} deleted file(s)`));
-    if (verbose) diff.deleted.forEach(d => console.log(chalk.red(`      - ${d.relativePath}`)));
-  }
-  if ((diff.conflicts || []).length) {
-    console.log(chalk.magenta(`    ! ${diff.conflicts.length} conflict(s)`));
-    if (verbose) diff.conflicts.forEach(c => console.log(chalk.magenta(`      ! ${c.relativePath}`)));
-  }
-  if ((diff.skipped || []).length && verbose) {
-    console.log(chalk.gray(`    = ${diff.skipped.length} skipped`));
-  }
-}
-
-function printResults(results) {
-  if (results.copied.length) console.log(chalk.green(`  Copied ${results.copied.length} file(s)`));
-  if (results.deleted.length) console.log(chalk.red(`  Deleted ${results.deleted.length} file(s)`));
-  if (results.skipped?.length) console.log(chalk.gray(`  Skipped ${results.skipped.length} file(s)`));
-  if (results.conflicted.length) {
-    console.log(chalk.magenta(`  ${results.conflicted.length} conflict(s) saved with .sync-conflict suffix`));
-    for (const c of results.conflicted) {
-      if (c.original) console.log(chalk.gray(`    ${c.original} -> ${c.conflictFile}`));
-    }
-  }
-  if (results.errors.length) {
-    console.log(chalk.red(`  ${results.errors.length} error(s):`));
-    for (const e of results.errors) console.log(chalk.red(`    ${e.file}: ${e.error}`));
-  }
-}
-
-// --- pe sync <path> <pal> (bi-directional, default) ---
-
-async function biSync(dirPath, palName, opts) {
-  let absolutePath, pal, identity, keyPair;
-  try {
-    absolutePath = validateDir(dirPath);
-    pal = findPal(palName);
-    identity = await getIdentity();
-    keyPair = getKeyPair();
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const options = parseSyncOptions(opts);
-  const palHandle = pal.handle || pal.name;
-  const palId = pal.id || pal.publicKey;
-
-  registerSyncHandlers();
-
-  console.log(chalk.blue(`Syncing ${absolutePath} with ${pal.name}...`));
-
-  let transport;
-  try {
-    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
-    console.log(chalk.gray(`  Transport: ${transport.type}`));
-  } catch (err) {
-    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
-    process.exitCode = 1;
-    return;
-  }
-
-  const existingPair = findSyncPair(absolutePath, palId);
-  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-
-  const session = new SyncSession({
-    localPath: absolutePath,
-    peerPK: palId,
-    transport,
-    keyPair,
-    syncPairId: pair.id,
-    options,
-  });
-
-  if (options.progress) {
-    session.on('state', (s) => console.log(chalk.gray(`  [${s}]`)));
-    session.on('manifestSent', (d) => console.log(chalk.gray(`  Sent manifest (${d.entries} files)`)));
-    session.on('manifestReceived', (d) => console.log(chalk.gray(`  Received manifest (${d.entries} files)`)));
-  }
-
-  try {
-    const { localManifest } = await session.start(cachedManifest);
-    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
-
-    // For bi-directional sync, we need the remote manifest
-    // In real P2P: remote peer would respond with their manifest
-    // Here we send ours and wait for theirs
-    console.log(chalk.blue(`  Waiting for ${pal.name}'s manifest...`));
-    console.log(chalk.gray('  (Manifest sent via PAL/1.0 protocol)'));
-
-    // Save local state
-    saveSyncManifest(pair.id, localManifest);
-    updateSyncPair(pair.id, {
-      lastSync: new Date().toISOString(),
-      status: 'synced',
-      lastDirection: 'sync',
-    });
-
-    addSyncHistoryEntry(pair.id, {
-      direction: 'sync',
-      totalFiles: localManifest.length,
-    });
-
-    session.finish();
-    console.log(chalk.green(`Sync manifest sent to ${pal.name}.`));
-    console.log(chalk.gray(`Sync pair: ${pair.id}`));
-  } catch (err) {
-    session.abort(err.message);
-    updateSyncPair(pair.id, { status: 'error' });
-    logger.error(`Sync failed: ${err.message}`);
-    console.log(chalk.red(`Sync failed: ${err.message}`));
-    process.exitCode = 1;
-  }
-}
-
-// --- pe sync push <path> <pal> ---
-
-async function pushSync(dirPath, palName, opts) {
-  let absolutePath, pal, identity, keyPair;
-  try {
-    absolutePath = validateDir(dirPath);
-    pal = findPal(palName);
-    identity = await getIdentity();
-    keyPair = getKeyPair();
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const options = parseSyncOptions(opts);
-  const palHandle = pal.handle || pal.name;
-  const palId = pal.id || pal.publicKey;
-
-  registerSyncHandlers();
-
-  console.log(chalk.blue(`Scanning ${absolutePath}...`));
-  const existingPair = findSyncPair(absolutePath, palId);
-  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
-  const manifest = await buildManifest(absolutePath, cachedManifest, options);
-  console.log(chalk.gray(`  ${manifest.length} file(s) indexed`));
-
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-  const lastManifest = getSyncManifest(pair.id);
-  const manifestMap = manifestToMap(manifest);
-
-  let added = 0, modified = 0, deleted = 0;
-  if (lastManifest) {
-    const lastMap = manifestToMap(lastManifest);
-    const diff = diffManifests(lastMap, manifestMap);
-    added = diff.added.length;
-    modified = diff.modified.length;
-    deleted = diff.deleted.length;
-
-    if (added === 0 && modified === 0 && deleted === 0) {
-      console.log(chalk.green('Already in sync. No changes to push.'));
-      return;
-    }
-
-    console.log(chalk.white(`  Changes: ${chalk.green(`+${added}`)} added, ${chalk.yellow(`~${modified}`)} modified, ${chalk.red(`-${deleted}`)} deleted`));
-  } else {
-    console.log(chalk.gray('  First sync for this pair.'));
-  }
-
-  if (options.dryRun) {
-    console.log(chalk.yellow('Dry run — no changes sent.'));
-    return;
-  }
-
-  // Select transport and send via PAL/1.0 protocol
-  let transport;
-  try {
-    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
-    console.log(chalk.gray(`  Transport: ${transport.type}`));
-  } catch (err) {
-    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
-    process.exitCode = 1;
-    return;
-  }
-
-  const session = new SyncSession({
-    localPath: absolutePath,
-    peerPK: palId,
-    transport,
-    keyPair,
-    syncPairId: pair.id,
-    options,
-  });
-
-  try {
-    await session.start(cachedManifest);
-
-    saveSyncManifest(pair.id, manifest);
-    updateSyncPair(pair.id, {
-      lastSync: new Date().toISOString(),
-      status: 'synced',
-      lastDirection: 'push',
-    });
-
-    addSyncHistoryEntry(pair.id, {
-      direction: 'push',
-      filesAdded: added || manifest.length,
-      filesModified: modified,
-      filesDeleted: deleted,
-      totalFiles: manifest.length,
-    });
-
-    session.finish();
-    console.log(chalk.green(`Push complete. Manifest sent to ${pal.name}.`));
-    console.log(chalk.gray(`Sync pair: ${pair.id}`));
-  } catch (err) {
-    session.abort(err.message);
-    updateSyncPair(pair.id, { status: 'error' });
-    logger.error(`Push sync failed: ${err.message}`);
-    console.log(chalk.red(`Push failed: ${err.message}`));
-    process.exitCode = 1;
-  }
-}
-
-// --- pe sync pull <path> <pal> ---
-
-async function pullSync(dirPath, palName, opts) {
-  let absolutePath, pal, identity, keyPair;
-  try {
-    absolutePath = validateDir(dirPath);
-    pal = findPal(palName);
-    identity = await getIdentity();
-    keyPair = getKeyPair();
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const options = parseSyncOptions(opts);
-  const palHandle = pal.handle || pal.name;
-  const palId = pal.id || pal.publicKey;
-
-  registerSyncHandlers();
-
-  console.log(chalk.blue(`Pulling from ${pal.name} to ${absolutePath}...`));
-
-  let transport;
-  try {
-    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
-    console.log(chalk.gray(`  Transport: ${transport.type}`));
-  } catch (err) {
-    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
-    process.exitCode = 1;
-    return;
-  }
-
-  const existingPair = findSyncPair(absolutePath, palId);
-  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-
-  const session = new SyncSession({
-    localPath: absolutePath,
-    peerPK: palId,
-    transport,
-    keyPair,
-    syncPairId: pair.id,
-    options,
-  });
-
-  try {
-    // Start session (sends our manifest to peer)
-    const { localManifest } = await session.start(cachedManifest);
-    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
-    console.log(chalk.blue(`  Manifest sent, waiting for ${pal.name}'s response...`));
-    console.log(chalk.gray('  (Pull request sent via PAL/1.0 protocol)'));
-
-    saveSyncManifest(pair.id, localManifest);
-    updateSyncPair(pair.id, {
-      lastSync: new Date().toISOString(),
-      status: 'synced',
-      lastDirection: 'pull',
-    });
-
-    addSyncHistoryEntry(pair.id, {
-      direction: 'pull',
-      totalFiles: localManifest.length,
-    });
-
-    session.finish();
-    console.log(chalk.green(`Pull request sent to ${pal.name}.`));
-  } catch (err) {
-    session.abort(err.message);
-    updateSyncPair(pair.id, { status: 'error' });
-    logger.error(`Pull sync failed: ${err.message}`);
-    console.log(chalk.red(`Pull failed: ${err.message}`));
-    process.exitCode = 1;
-  }
-}
-
-// --- pe sync watch <path> <pal> ---
-
-async function watchSync(dirPath, palName, opts) {
-  let absolutePath, pal, keyPair;
-  try {
-    absolutePath = validateDir(dirPath);
-    pal = findPal(palName);
-    getIdentity();
-    keyPair = getKeyPair();
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const options = parseSyncOptions(opts);
-  const palHandle = pal.handle || pal.name;
-  const palId = pal.id || pal.publicKey;
-
-  registerSyncHandlers();
-
-  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-
-  console.log(chalk.blue(`Watching ${absolutePath} for changes...`));
-  console.log(chalk.gray(`Syncing to ${pal.name}. Press Ctrl+C to stop.`));
-
-  let debounceTimer = null;
-  const debounceMs = 2000;
-  let syncing = false;
-
-  const triggerSync = async () => {
-    if (syncing) return;
-    syncing = true;
-
-    try {
-      const lastManifest = getSyncManifest(pair.id);
-      const manifest = await buildManifest(absolutePath, lastManifest, options);
-
-      if (lastManifest) {
-        const lastMap = manifestToMap(lastManifest);
-        const currentMap = manifestToMap(manifest);
-        const diff = diffManifests(lastMap, currentMap);
-        const total = diff.added.length + diff.modified.length + diff.deleted.length;
-        if (total === 0) {
-          syncing = false;
-          return;
-        }
-        console.log(chalk.blue(`Change detected: ${chalk.green(`+${diff.added.length}`)} ${chalk.yellow(`~${diff.modified.length}`)} ${chalk.red(`-${diff.deleted.length}`)}`));
-      } else {
-        console.log(chalk.blue(`Initial sync: ${manifest.length} file(s)`));
-      }
-
-      // Select transport and send via PAL/1.0
-      const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
-      const session = new SyncSession({
-        localPath: absolutePath,
-        peerPK: palId,
-        transport,
-        keyPair,
-        syncPairId: pair.id,
-        options,
-      });
-
-      await session.start(lastManifest);
-
-      saveSyncManifest(pair.id, manifest);
-      updateSyncPair(pair.id, {
-        lastSync: new Date().toISOString(),
-        status: 'synced',
-        lastDirection: 'push',
-      });
-
-      addSyncHistoryEntry(pair.id, {
-        direction: 'push',
-        totalFiles: manifest.length,
-        auto: true,
-      });
-
-      session.finish();
-      console.log(chalk.green(`Synced to ${pal.name} at ${new Date().toLocaleTimeString()}`));
-    } catch (err) {
-      logger.error(`Watch sync failed: ${err.message}`);
-      console.log(chalk.yellow(`Sync failed: ${err.message}`));
-    } finally {
-      syncing = false;
-    }
-  };
-
-  try {
-    const watcher = fs.watch(absolutePath, { recursive: true }, (_event, filename) => {
-      if (filename && /node_modules|\.git/.test(filename)) return;
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(triggerSync, debounceMs);
-    });
-    process.on('SIGINT', () => { watcher.close(); process.exit(0); });
-  } catch (err) {
-    console.log(chalk.red(`Watch failed: ${err.message}`));
-    process.exitCode = 1;
-    return;
-  }
-
-  triggerSync();
-}
-
-// --- pe sync status <path> ---
-
-async function syncStatus(dirPath) {
-  if (!dirPath) {
-    const pairs = getSyncPairs();
-    if (pairs.length === 0) {
-      console.log(chalk.gray('No sync pairs configured. Use `pe sync <path> <pal>` to start.'));
-      return;
-    }
-
-    const friends = getFriends();
-    console.log('');
-    console.log(chalk.cyan.bold('Sync Pairs'));
-    console.log('');
-
-    for (const pair of pairs) {
-      const pal = friends.find(f => f.id === pair.palId);
-      const palName = pal?.name || pair.palId;
-      const statusColor =
-        pair.status === 'synced' ? chalk.green :
-        pair.status === 'error' ? chalk.red :
-        pair.status === 'pending-download' ? chalk.yellow :
-        chalk.gray;
-
-      console.log(`  ${chalk.white(pair.localPath)} ${chalk.gray('->')} ${chalk.yellow(palName)}`);
-      console.log(`    Status: ${statusColor(pair.status)}  Direction: ${pair.lastDirection || '-'}  Last: ${pair.lastSync || 'never'}`);
-      console.log(`    ${chalk.gray(`ID: ${pair.id}`)}`);
-    }
-    console.log('');
-    return;
-  }
-
-  let absolutePath;
-  try {
-    absolutePath = validateDir(dirPath);
-  } catch (err) {
-    console.log(chalk.red(err.message));
-    process.exitCode = 1;
-    return;
-  }
-
-  const pairs = getSyncPairs().filter(p => p.localPath === absolutePath);
-  if (pairs.length === 0) {
-    console.log(chalk.yellow(`No sync pairs for ${absolutePath}.`));
-    console.log(chalk.gray('Use `pe sync <path> <pal>` to create one.'));
-    return;
-  }
-
-  const friends = getFriends();
-  console.log('');
-  console.log(chalk.cyan.bold(`Sync Status: ${absolutePath}`));
-  console.log('');
-
-  const statusCached = pairs.length === 1 ? getSyncManifest(pairs[0].id) : null;
-  const currentManifest = await buildManifest(absolutePath, statusCached);
-  const currentMap = manifestToMap(currentManifest);
-
-  for (const pair of pairs) {
-    const pal = friends.find(f => f.id === pair.palId);
-    const palName = pal?.name || pair.palId;
-    const lastManifest = getSyncManifest(pair.id);
-
-    console.log(`  ${chalk.yellow(palName)} (${pair.status})`);
-
-    if (!lastManifest) {
-      console.log(chalk.gray('    No previous sync. All files will be synced.'));
-      console.log(`    ${chalk.white(`${currentManifest.length} file(s) to push`)}`);
-    } else {
-      const lastMap = manifestToMap(lastManifest);
-      const diff = diffManifests(lastMap, currentMap);
-      const total = diff.added.length + diff.modified.length + diff.deleted.length;
-
-      if (total === 0) {
-        console.log(chalk.green('    In sync. No local changes.'));
-      } else {
-        console.log(`    ${chalk.green(`+${diff.added.length}`)} added  ${chalk.yellow(`~${diff.modified.length}`)} modified  ${chalk.red(`-${diff.deleted.length}`)} deleted`);
-        if (diff.added.length <= 5) {
-          for (const a of diff.added) console.log(chalk.green(`      + ${a.relativePath}`));
-        }
-        if (diff.modified.length <= 5) {
-          for (const m of diff.modified) console.log(chalk.yellow(`      ~ ${m.relativePath}`));
-        }
-        if (diff.deleted.length <= 5) {
-          for (const d of diff.deleted) console.log(chalk.red(`      - ${d.relativePath}`));
-        }
-      }
-    }
-
-    const history = getSyncHistory(pair.id);
-    if (history.length > 0) {
-      console.log(chalk.gray(`    Last ${Math.min(history.length, 3)} syncs:`));
-      for (const h of history.slice(0, 3)) {
-        const dir = h.direction === 'push' ? chalk.blue('PUSH') :
-                    h.direction === 'pull' ? chalk.magenta('PULL') :
-                    chalk.cyan('SYNC');
-        const changes = [];
-        if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
-        if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
-        if (h.filesDeleted) changes.push(chalk.red(`-${h.filesDeleted}`));
-        if (h.conflicts) changes.push(chalk.magenta(`!${h.conflicts}`));
-        console.log(chalk.gray(`      ${h.timestamp}  ${dir}  ${changes.join(' ')}${h.auto ? chalk.gray(' [auto]') : ''}`));
-      }
-    }
-    console.log('');
-  }
-}
-
-// --- pe sync remove <id> ---
-
-function removePair(id) {
-  const pairs = getSyncPairs();
-  const pair = pairs.find(p => p.id === id);
-  if (!pair) {
-    console.log(chalk.red(`Sync pair '${id}' not found.`));
-    process.exitCode = 1;
-    return;
-  }
-  removeSyncPair(id);
-  console.log(chalk.green(`Removed sync pair ${id}.`));
-}
-
-function parseInterval(str) {
-  const match = str.match(/^(\d+)(s|m|h)$/);
-  if (!match) return null;
-  const [, num, unit] = match;
-  const multipliers = { s: 1000, m: 60000, h: 3600000 };
-  return parseInt(num, 10) * multipliers[unit];
-}
-
-function formatSyncBytes(b) {
-  if (!b) return '0 B';
-  if (b < 1024) return b + ' B';
-  if (b < 1048576) return (b / 1024).toFixed(1) + ' KB';
-  if (b < 1073741824) return (b / 1048576).toFixed(1) + ' MB';
-  return (b / 1073741824).toFixed(2) + ' GB';
-}
-
-// --- Command registration ---
-
-export default function syncCommand(program) {
-  const cmd = program
-    .command('sync')
-    .description('sync directories with pals (rsync-like P2P sync)');
-
-  // Default: pe sync <path> <pal> — bi-directional
-  const defaultSync = cmd
-    .command('start <path> <pal>')
-    .description('bi-directional sync with a pal (default)')
-    .action(async (syncPath, pal, cliOpts) => {
-      if (!syncPath?.trim()) {
-        console.log(chalk.red('Error: path cannot be empty.'));
-        process.exitCode = 1;
-        return;
-      }
-      await biSync(syncPath, pal, cliOpts);
-    });
-  addSyncFlagsToCommand(defaultSync);
-
-  const pushCmd = cmd
-    .command('push <path> <pal>')
-    .description('push local changes to a pal (one-way)')
-    .action(async (syncPath, pal, cliOpts) => {
-      if (!syncPath?.trim()) {
-        console.log(chalk.red('Error: path cannot be empty.'));
-        process.exitCode = 1;
-        return;
-      }
-      await pushSync(syncPath, pal, cliOpts);
-    });
-  addSyncFlagsToCommand(pushCmd);
-
-  const pullCmd = cmd
-    .command('pull <path> <pal>')
-    .description('pull changes from a pal (one-way)')
-    .action(async (syncPath, pal, cliOpts) => {
-      if (!syncPath?.trim()) {
-        console.log(chalk.red('Error: path cannot be empty.'));
-        process.exitCode = 1;
-        return;
-      }
-      await pullSync(syncPath, pal, cliOpts);
-    });
-  addSyncFlagsToCommand(pullCmd);
-
-  const watchCmd = cmd
-    .command('watch <path> <pal>')
-    .description('watch directory and auto-sync on changes')
-    .action(async (syncPath, pal, cliOpts) => {
-      await watchSync(syncPath, pal, cliOpts);
-    });
-  addSyncFlagsToCommand(watchCmd);
-
-  cmd
-    .command('status [path]')
-    .description('show sync status and changes since last sync')
-    .action((syncPath) => {
-      syncStatus(syncPath);
-    });
-
-  cmd
-    .command('list')
-    .description('list all sync pairs')
-    .action(() => {
-      syncStatus();
-    });
-
-  cmd
-    .command('remove <id>')
-    .description('remove a sync pair')
-    .action((id) => {
-      removePair(id);
-    });
-
-  cmd
-    .command('history [pairId]')
-    .description('view sync history')
-    .action((pairId) => {
-      const pairs = getSyncPairs();
-      if (pairs.length === 0) {
-        console.log(chalk.gray('No sync pairs configured.'));
-        return;
-      }
-
-      const friends = getFriends();
-      const targetPairs = pairId ? pairs.filter(p => p.id === pairId) : pairs;
-      if (targetPairs.length === 0) {
-        console.log(chalk.red(`Sync pair '${pairId}' not found.`));
-        process.exitCode = 1;
-        return;
-      }
-
-      console.log('');
-      console.log(chalk.cyan.bold('Sync History'));
-      console.log('');
-
-      for (const pair of targetPairs) {
-        const pal = friends.find(f => f.id === pair.palId);
-        const palName = pal?.name || pair.palId;
-        console.log(`  ${chalk.white(pair.localPath)} ${chalk.gray('->')} ${chalk.yellow(palName)}`);
-        console.log(`  ${chalk.gray(`ID: ${pair.id}`)}`);
-
-        const history = getSyncHistory(pair.id);
-        if (history.length === 0) {
-          console.log(chalk.gray('    No history yet.'));
-        } else {
-          for (const h of history) {
-            const dir = h.direction === 'push' ? chalk.blue('PUSH') :
-                        h.direction === 'pull' ? chalk.magenta('PULL') :
-                        chalk.cyan('SYNC');
-            const changes = [];
-            if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
-            if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
-            if (h.filesDeleted) changes.push(chalk.red(`-${h.filesDeleted}`));
-            if (h.conflicts) changes.push(chalk.magenta(`!${h.conflicts}`));
-            if (h.totalFiles) changes.push(chalk.gray(`(${h.totalFiles} total)`));
-            console.log(`    ${chalk.gray(h.timestamp)}  ${dir}  ${changes.join(' ')}${h.auto ? chalk.gray(' [auto]') : ''}`);
-          }
-        }
-        console.log('');
-      }
-    });
-
-  cmd
-    .command('diff <localPath> <remotePath>')
-    .description('compare local and remote folders, show what needs to transfer')
-    .option('--json', 'Output as JSON')
-    .action(async (localPath, remotePath, cmdOpts) => {
-      try {
-        console.log(chalk.blue('Building local manifest...'));
-        const localManifest = buildDiffManifest(localPath);
-        console.log(chalk.blue('Building remote manifest...'));
-        const remoteManifest = buildDiffManifest(remotePath);
-
-        const diff = diffFileManifests(localManifest, remoteManifest);
-        const summary = diffSummary(diff);
-
-        if (cmdOpts.json) {
-          console.log(JSON.stringify({ diff, summary }, null, 2));
-          return;
-        }
-
-        console.log();
-        if (diff.added.length > 0) {
-          console.log(chalk.green(`  + ${diff.added.length} new files`));
-          diff.added.forEach(f => console.log(chalk.green(`    + ${f.path} (${formatSyncBytes(f.size)})`)));
-        }
-        if (diff.modified.length > 0) {
-          console.log(chalk.yellow(`  ~ ${diff.modified.length} modified files`));
-          diff.modified.forEach(f => console.log(chalk.yellow(`    ~ ${f.path} (${formatSyncBytes(f.size)})`)));
-        }
-        if (diff.deleted.length > 0) {
-          console.log(chalk.red(`  - ${diff.deleted.length} deleted files`));
-          diff.deleted.forEach(f => console.log(chalk.red(`    - ${f.path}`)));
-        }
-        if (diff.unchanged.length > 0) {
-          console.log(chalk.gray(`  = ${diff.unchanged.length} unchanged files`));
-        }
-
-        console.log();
-        console.log(chalk.white(`  Transfer needed: ${formatSyncBytes(summary.transferBytes)} (${summary.addedCount + summary.modifiedCount} files)`));
-        console.log(chalk.gray(`  Skipping: ${summary.skippedFiles} files already up to date`));
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
-
-  // --- pe sync profile save/list/use ---
-  const profileCmd = cmd.command('profile').description('manage sync flag profiles');
-
-  profileCmd
-    .command('save <name>')
-    .description('save current flags as a named profile')
-    .action((name, _opts, profileCommand) => {
-      // Collect flags from parent command context
-      const parentOpts = profileCommand.parent?.parent?.opts() || {};
-      const profiles = config.get('syncProfiles') || {};
-      const profile = {};
-      for (const key of ['exclude', 'include', 'delete', 'checksum', 'sizeOnly', 'update',
-        'ignoreExisting', 'backup', 'compress', 'bandwidthLimit', 'archive']) {
-        if (parentOpts[key] !== undefined) profile[key] = parentOpts[key];
-      }
-      profiles[name] = profile;
-      config.set('syncProfiles', profiles);
-      console.log(chalk.green(`Profile '${name}' saved.`));
-      if (Object.keys(profile).length === 0) {
-        console.log(chalk.gray('  (empty profile — use with sync flags to save them)'));
-      } else {
-        for (const [k, v] of Object.entries(profile)) {
-          console.log(chalk.gray(`  ${k}: ${JSON.stringify(v)}`));
-        }
-      }
-    });
-
-  profileCmd
-    .command('list')
-    .description('list saved profiles')
-    .action(() => {
-      const profiles = config.get('syncProfiles') || {};
-      const names = Object.keys(profiles);
-      if (names.length === 0) {
-        console.log(chalk.gray('No saved profiles. Use `pe sync profile save <name>` to create one.'));
-        return;
-      }
-      console.log('');
-      console.log(chalk.cyan.bold('Sync Profiles'));
-      for (const name of names) {
-        const p = profiles[name];
-        const flags = Object.entries(p).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(', ');
-        console.log(`  ${chalk.white(name)}: ${chalk.gray(flags || '(empty)')}`);
-      }
-      console.log('');
-    });
-
-  profileCmd
-    .command('use <name>')
-    .description('show flags for a profile (use with eval or copy)')
-    .action((name) => {
-      const profiles = config.get('syncProfiles') || {};
-      const profile = profiles[name];
-      if (!profile) {
-        console.log(chalk.red(`Profile '${name}' not found.`));
-        process.exitCode = 1;
-        return;
-      }
-      const flags = [];
-      if (profile.exclude) {
-        const arr = Array.isArray(profile.exclude) ? profile.exclude : [profile.exclude];
-        arr.forEach(p => flags.push(`--exclude "${p}"`));
-      }
-      if (profile.include) {
-        const arr = Array.isArray(profile.include) ? profile.include : [profile.include];
-        arr.forEach(p => flags.push(`--include "${p}"`));
-      }
-      if (profile.delete) flags.push('--delete');
-      if (profile.checksum) flags.push('--checksum');
-      if (profile.sizeOnly) flags.push('--size-only');
-      if (profile.update) flags.push('--update');
-      if (profile.ignoreExisting) flags.push('--ignore-existing');
-      if (profile.backup) flags.push('--backup');
-      if (profile.compress) flags.push('--compress');
-      if (profile.bandwidthLimit) flags.push(`--bandwidth-limit ${profile.bandwidthLimit}`);
-      if (profile.archive) flags.push('--archive');
-
-      console.log(flags.join(' ') || '(no flags)');
-    });
-
-  profileCmd
-    .command('delete <name>')
-    .description('delete a saved profile')
-    .action((name) => {
-      const profiles = config.get('syncProfiles') || {};
-      if (!profiles[name]) {
-        console.log(chalk.red(`Profile '${name}' not found.`));
-        process.exitCode = 1;
-        return;
-      }
-      delete profiles[name];
-      config.set('syncProfiles', profiles);
-      console.log(chalk.green(`Profile '${name}' deleted.`));
-    });
-
-  // --- pe sync schedule <path> <pal> --every <interval> ---
-  cmd
-    .command('schedule <path> <pal>')
-    .description('background sync at intervals')
-    .requiredOption('--every <interval>', 'sync interval (e.g., 5m, 1h, 30s)')
-    .action(async (syncPath, pal, schedOpts) => {
-      let absolutePath, palObj, keyPair;
-      try {
-        absolutePath = validateDir(syncPath);
-        palObj = findPal(pal);
-        getIdentity();
-        keyPair = getKeyPair();
-      } catch (err) {
-        console.log(chalk.red(err.message));
-        process.exitCode = 1;
-        return;
-      }
-
-      const intervalMs = parseInterval(schedOpts.every);
-      if (!intervalMs || intervalMs < 5000) {
-        console.log(chalk.red('Invalid interval. Minimum: 5s. Examples: 30s, 5m, 1h'));
-        process.exitCode = 1;
-        return;
-      }
-
-      const palHandle = palObj.handle || palObj.name;
-      const palId = palObj.id || palObj.publicKey;
-      const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
-
-      registerSyncHandlers();
-
-      console.log(chalk.blue(`Scheduled sync: ${absolutePath} -> ${palObj.name} every ${schedOpts.every}`));
-      console.log(chalk.gray('Press Ctrl+C to stop.'));
-
-      const doSync = async () => {
-        try {
-          const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
-          const lastManifest = getSyncManifest(pair.id);
-          const session = new SyncSession({
-            localPath: absolutePath,
-            peerPK: palId,
-            transport,
-            keyPair,
-            syncPairId: pair.id,
-          });
-          await session.start(lastManifest);
-          const manifest = session.localManifest;
-          saveSyncManifest(pair.id, manifest);
-          updateSyncPair(pair.id, {
-            lastSync: new Date().toISOString(),
-            status: 'synced',
-            lastDirection: 'push',
-          });
-          addSyncHistoryEntry(pair.id, {
-            direction: 'push',
-            totalFiles: manifest.length,
-            auto: true,
-          });
-          session.finish();
-          console.log(chalk.green(`  Synced at ${new Date().toLocaleTimeString()} (${manifest.length} files)`));
-        } catch (err) {
-          console.log(chalk.yellow(`  Sync failed: ${err.message}`));
-        }
-      };
-
-      doSync();
-      const timer = setInterval(doSync, intervalMs);
-      process.on('SIGINT', () => { clearInterval(timer); process.exit(0); });
-    });
-
-  cmd.addHelpText('after', `
-${chalk.cyan('Examples:')}
-  $ pe sync start ./project alice       Bi-directional sync with alice
-  $ pe sync push ./project alice        Push local changes to alice
-  $ pe sync pull ./project alice        Pull alice's changes locally
-  $ pe sync watch ./project alice       Watch and auto-sync on changes
-  $ pe sync status ./project            Show what changed since last sync
-  $ pe sync status                      Show all sync pairs
-
-${chalk.cyan('rsync-like flags:')}
-  $ pe sync push ./project alice --dry-run          Preview without applying
-  $ pe sync push ./project alice --exclude "*.log"  Skip log files
-  $ pe sync push ./project alice --delete           Remove files not in source
-  $ pe sync push ./project alice --compress          Compress transfer
-  $ pe sync push ./project alice --progress          Show progress
-  $ pe sync push ./project alice --archive           --recursive --checksum --delete
-  $ pe sync push ./project alice --backup            Create .bak before overwriting
-  $ pe sync push ./project alice --bandwidth-limit 500  Throttle to 500 KB/s
-
-${chalk.cyan('How it works:')}
-  1. Sync uses PAL/1.0 protocol over LAN (TCP:7474) or WebRTC (internet).
-  2. No discovery server required for LAN sync.
-  3. Manifests are signed and encrypted (Ed25519 + XChaCha20-Poly1305).
-  4. Conflicts create ${chalk.magenta('.sync-conflict')} copies — no data loss.
-  5. ${chalk.white('watch')} monitors your directory and auto-syncs on changes.
-`);
-}
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import config from '../utils/config.js';
+import logger from '../utils/logger.js';
+import { buildManifest as buildDiffManifest, diffManifests as diffFileManifests, diffSummary } from '../core/fileDiff.js';
+import { getFriends } from '../core/users.js';
+import {
+  buildManifest,
+  diffManifests,
+  manifestToMap,
+  detectConflicts,
+  applyDiff,
+  formatSize,
+  SyncSession,
+} from '../core/syncEngine.js';
+import {
+  getSyncPairs,
+  addSyncPair,
+  removeSyncPair,
+  updateSyncPair,
+  findSyncPair,
+  saveSyncManifest,
+  getSyncManifest,
+  getLastSyncedManifestMap,
+  addSyncHistoryEntry,
+  getSyncHistory,
+} from '../core/syncState.js';
+import { selectSyncTransport } from '../core/syncTransport.js';
+import { registerSyncHandlers } from '../core/syncProtocolHandlers.js';
+import { parseSyncOptions, addSyncFlagsToCommand } from '../core/syncOptions.js';
+
+function getIdentity() {
+  const identity = config.get('identity');
+  if (!identity?.handle) {
+    throw new Error('Not registered. Run `pal init` and `pal register` first.');
+  }
+  return identity;
+}
+
+function getKeyPair() {
+  const identity = config.get('identity');
+  if (!identity?.publicKey || !identity?.privateKey) {
+    throw new Error('Identity keys not configured. Run `pal init` first.');
+  }
+  return {
+    publicKey: Buffer.from(identity.publicKey, 'hex'),
+    secretKey: Buffer.from(identity.privateKey, 'hex'),
+  };
+}
+
+function findPal(palName) {
+  const friends = getFriends();
+  const pal = friends.find(f => f.name === palName || f.id === palName || f.handle === palName);
+  if (!pal) {
+    throw new Error(`Pal '${palName}' not found. Add them first with \`pal pal add\`.`);
+  }
+  return pal;
+}
+
+function validateDir(dirPath) {
+  const abs = path.resolve(dirPath);
+  if (!fs.existsSync(abs)) {
+    throw new Error(`Path not found: ${abs}`);
+  }
+  if (!fs.statSync(abs).isDirectory()) {
+    throw new Error('Sync only works with directories. Use `pal share` for single files.');
+  }
+  return abs;
+}
+
+function printDiffSummary(diff, verbose) {
+  if (diff.added.length) {
+    console.log(chalk.green(`    + ${diff.added.length} new file(s)`));
+    if (verbose) diff.added.forEach(a => console.log(chalk.green(`      + ${a.relativePath}`)));
+  }
+  if (diff.modified.length) {
+    console.log(chalk.yellow(`    ~ ${diff.modified.length} modified file(s)`));
+    if (verbose) diff.modified.forEach(m => console.log(chalk.yellow(`      ~ ${m.relativePath}`)));
+  }
+  if (diff.deleted.length) {
+    console.log(chalk.red(`    - ${diff.deleted.length} deleted file(s)`));
+    if (verbose) diff.deleted.forEach(d => console.log(chalk.red(`      - ${d.relativePath}`)));
+  }
+  if ((diff.conflicts || []).length) {
+    console.log(chalk.magenta(`    ! ${diff.conflicts.length} conflict(s)`));
+    if (verbose) diff.conflicts.forEach(c => console.log(chalk.magenta(`      ! ${c.relativePath}`)));
+  }
+  if ((diff.skipped || []).length && verbose) {
+    console.log(chalk.gray(`    = ${diff.skipped.length} skipped`));
+  }
+}
+
+function printResults(results) {
+  if (results.copied.length) console.log(chalk.green(`  Copied ${results.copied.length} file(s)`));
+  if (results.deleted.length) console.log(chalk.red(`  Deleted ${results.deleted.length} file(s)`));
+  if (results.skipped?.length) console.log(chalk.gray(`  Skipped ${results.skipped.length} file(s)`));
+  if (results.conflicted.length) {
+    console.log(chalk.magenta(`  ${results.conflicted.length} conflict(s) saved with .sync-conflict suffix`));
+    for (const c of results.conflicted) {
+      if (c.original) console.log(chalk.gray(`    ${c.original} -> ${c.conflictFile}`));
+    }
+  }
+  if (results.errors.length) {
+    console.log(chalk.red(`  ${results.errors.length} error(s):`));
+    for (const e of results.errors) console.log(chalk.red(`    ${e.file}: ${e.error}`));
+  }
+}
+
+// --- pal sync <path> <pal> (bi-directional, default) ---
+
+async function biSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    identity = await getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  console.log(chalk.blue(`Syncing ${absolutePath} with ${pal.name}...`));
+
+  let transport;
+  try {
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
+  } catch (err) {
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const existingPair = findSyncPair(absolutePath, palId);
+  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
+
+  if (options.progress) {
+    session.on('state', (s) => console.log(chalk.gray(`  [${s}]`)));
+    session.on('manifestSent', (d) => console.log(chalk.gray(`  Sent manifest (${d.entries} files)`)));
+    session.on('manifestReceived', (d) => console.log(chalk.gray(`  Received manifest (${d.entries} files)`)));
+  }
+
+  try {
+    const { localManifest } = await session.start(cachedManifest);
+    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
+
+    // For bi-directional sync, we need the remote manifest
+    // In real P2P: remote peer would respond with their manifest
+    // Here we send ours and wait for theirs
+    console.log(chalk.blue(`  Waiting for ${pal.name}'s manifest...`));
+    console.log(chalk.gray('  (Manifest sent via PAL/1.0 protocol)'));
+
+    // Save local state
+    saveSyncManifest(pair.id, localManifest);
+    updateSyncPair(pair.id, {
+      lastSync: new Date().toISOString(),
+      status: 'synced',
+      lastDirection: 'sync',
+    });
+
+    addSyncHistoryEntry(pair.id, {
+      direction: 'sync',
+      totalFiles: localManifest.length,
+    });
+
+    session.finish();
+    console.log(chalk.green(`Sync manifest sent to ${pal.name}.`));
+    console.log(chalk.gray(`Sync pair: ${pair.id}`));
+  } catch (err) {
+    session.abort(err.message);
+    updateSyncPair(pair.id, { status: 'error' });
+    logger.error(`Sync failed: ${err.message}`);
+    console.log(chalk.red(`Sync failed: ${err.message}`));
+    process.exitCode = 1;
+  }
+}
+
+// --- pal sync push <path> <pal> ---
+
+async function pushSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    identity = await getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  console.log(chalk.blue(`Scanning ${absolutePath}...`));
+  const existingPair = findSyncPair(absolutePath, palId);
+  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
+  const manifest = await buildManifest(absolutePath, cachedManifest, options);
+  console.log(chalk.gray(`  ${manifest.length} file(s) indexed`));
+
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+  const lastManifest = getSyncManifest(pair.id);
+  const manifestMap = manifestToMap(manifest);
+
+  let added = 0, modified = 0, deleted = 0;
+  if (lastManifest) {
+    const lastMap = manifestToMap(lastManifest);
+    const diff = diffManifests(lastMap, manifestMap);
+    added = diff.added.length;
+    modified = diff.modified.length;
+    deleted = diff.deleted.length;
+
+    if (added === 0 && modified === 0 && deleted === 0) {
+      console.log(chalk.green('Already in sync. No changes to push.'));
+      return;
+    }
+
+    console.log(chalk.white(`  Changes: ${chalk.green(`+${added}`)} added, ${chalk.yellow(`~${modified}`)} modified, ${chalk.red(`-${deleted}`)} deleted`));
+  } else {
+    console.log(chalk.gray('  First sync for this pair.'));
+  }
+
+  if (options.dryRun) {
+    console.log(chalk.yellow('Dry run — no changes sent.'));
+    return;
+  }
+
+  // Select transport and send via PAL/1.0 protocol
+  let transport;
+  try {
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
+  } catch (err) {
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
+
+  try {
+    await session.start(cachedManifest);
+
+    saveSyncManifest(pair.id, manifest);
+    updateSyncPair(pair.id, {
+      lastSync: new Date().toISOString(),
+      status: 'synced',
+      lastDirection: 'push',
+    });
+
+    addSyncHistoryEntry(pair.id, {
+      direction: 'push',
+      filesAdded: added || manifest.length,
+      filesModified: modified,
+      filesDeleted: deleted,
+      totalFiles: manifest.length,
+    });
+
+    session.finish();
+    console.log(chalk.green(`Push complete. Manifest sent to ${pal.name}.`));
+    console.log(chalk.gray(`Sync pair: ${pair.id}`));
+  } catch (err) {
+    session.abort(err.message);
+    updateSyncPair(pair.id, { status: 'error' });
+    logger.error(`Push sync failed: ${err.message}`);
+    console.log(chalk.red(`Push failed: ${err.message}`));
+    process.exitCode = 1;
+  }
+}
+
+// --- pal sync pull <path> <pal> ---
+
+async function pullSync(dirPath, palName, opts) {
+  let absolutePath, pal, identity, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    identity = await getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  console.log(chalk.blue(`Pulling from ${pal.name} to ${absolutePath}...`));
+
+  let transport;
+  try {
+    transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+    console.log(chalk.gray(`  Transport: ${transport.type}`));
+  } catch (err) {
+    console.log(chalk.red(`Cannot reach ${pal.name}: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  const existingPair = findSyncPair(absolutePath, palId);
+  const cachedManifest = existingPair ? getSyncManifest(existingPair.id) : null;
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+  const session = new SyncSession({
+    localPath: absolutePath,
+    peerPK: palId,
+    transport,
+    keyPair,
+    syncPairId: pair.id,
+    options,
+  });
+
+  try {
+    // Start session (sends our manifest to peer)
+    const { localManifest } = await session.start(cachedManifest);
+    console.log(chalk.gray(`  ${localManifest.length} local file(s) indexed`));
+    console.log(chalk.blue(`  Manifest sent, waiting for ${pal.name}'s response...`));
+    console.log(chalk.gray('  (Pull request sent via PAL/1.0 protocol)'));
+
+    saveSyncManifest(pair.id, localManifest);
+    updateSyncPair(pair.id, {
+      lastSync: new Date().toISOString(),
+      status: 'synced',
+      lastDirection: 'pull',
+    });
+
+    addSyncHistoryEntry(pair.id, {
+      direction: 'pull',
+      totalFiles: localManifest.length,
+    });
+
+    session.finish();
+    console.log(chalk.green(`Pull request sent to ${pal.name}.`));
+  } catch (err) {
+    session.abort(err.message);
+    updateSyncPair(pair.id, { status: 'error' });
+    logger.error(`Pull sync failed: ${err.message}`);
+    console.log(chalk.red(`Pull failed: ${err.message}`));
+    process.exitCode = 1;
+  }
+}
+
+// --- pal sync watch <path> <pal> ---
+
+async function watchSync(dirPath, palName, opts) {
+  let absolutePath, pal, keyPair;
+  try {
+    absolutePath = validateDir(dirPath);
+    pal = findPal(palName);
+    getIdentity();
+    keyPair = getKeyPair();
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const options = parseSyncOptions(opts);
+  const palHandle = pal.handle || pal.name;
+  const palId = pal.id || pal.publicKey;
+
+  registerSyncHandlers();
+
+  const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+  console.log(chalk.blue(`Watching ${absolutePath} for changes...`));
+  console.log(chalk.gray(`Syncing to ${pal.name}. Press Ctrl+C to stop.`));
+
+  let debounceTimer = null;
+  const debounceMs = 2000;
+  let syncing = false;
+
+  const triggerSync = async () => {
+    if (syncing) return;
+    syncing = true;
+
+    try {
+      const lastManifest = getSyncManifest(pair.id);
+      const manifest = await buildManifest(absolutePath, lastManifest, options);
+
+      if (lastManifest) {
+        const lastMap = manifestToMap(lastManifest);
+        const currentMap = manifestToMap(manifest);
+        const diff = diffManifests(lastMap, currentMap);
+        const total = diff.added.length + diff.modified.length + diff.deleted.length;
+        if (total === 0) {
+          syncing = false;
+          return;
+        }
+        console.log(chalk.blue(`Change detected: ${chalk.green(`+${diff.added.length}`)} ${chalk.yellow(`~${diff.modified.length}`)} ${chalk.red(`-${diff.deleted.length}`)}`));
+      } else {
+        console.log(chalk.blue(`Initial sync: ${manifest.length} file(s)`));
+      }
+
+      // Select transport and send via PAL/1.0
+      const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+      const session = new SyncSession({
+        localPath: absolutePath,
+        peerPK: palId,
+        transport,
+        keyPair,
+        syncPairId: pair.id,
+        options,
+      });
+
+      await session.start(lastManifest);
+
+      saveSyncManifest(pair.id, manifest);
+      updateSyncPair(pair.id, {
+        lastSync: new Date().toISOString(),
+        status: 'synced',
+        lastDirection: 'push',
+      });
+
+      addSyncHistoryEntry(pair.id, {
+        direction: 'push',
+        totalFiles: manifest.length,
+        auto: true,
+      });
+
+      session.finish();
+      console.log(chalk.green(`Synced to ${pal.name} at ${new Date().toLocaleTimeString()}`));
+    } catch (err) {
+      logger.error(`Watch sync failed: ${err.message}`);
+      console.log(chalk.yellow(`Sync failed: ${err.message}`));
+    } finally {
+      syncing = false;
+    }
+  };
+
+  try {
+    const watcher = fs.watch(absolutePath, { recursive: true }, (_event, filename) => {
+      if (filename && /node_modules|\.git/.test(filename)) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(triggerSync, debounceMs);
+    });
+    process.on('SIGINT', () => { watcher.close(); process.exit(0); });
+  } catch (err) {
+    console.log(chalk.red(`Watch failed: ${err.message}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  triggerSync();
+}
+
+// --- pal sync status <path> ---
+
+async function syncStatus(dirPath) {
+  if (!dirPath) {
+    const pairs = getSyncPairs();
+    if (pairs.length === 0) {
+      console.log(chalk.gray('No sync pairs configured. Use `pal sync <path> <pal>` to start.'));
+      return;
+    }
+
+    const friends = getFriends();
+    console.log('');
+    console.log(chalk.cyan.bold('Sync Pairs'));
+    console.log('');
+
+    for (const pair of pairs) {
+      const pal = friends.find(f => f.id === pair.palId);
+      const palName = pal?.name || pair.palId;
+      const statusColor =
+        pair.status === 'synced' ? chalk.green :
+        pair.status === 'error' ? chalk.red :
+        pair.status === 'pending-download' ? chalk.yellow :
+        chalk.gray;
+
+      console.log(`  ${chalk.white(pair.localPath)} ${chalk.gray('->')} ${chalk.yellow(palName)}`);
+      console.log(`    Status: ${statusColor(pair.status)}  Direction: ${pair.lastDirection || '-'}  Last: ${pair.lastSync || 'never'}`);
+      console.log(`    ${chalk.gray(`ID: ${pair.id}`)}`);
+    }
+    console.log('');
+    return;
+  }
+
+  let absolutePath;
+  try {
+    absolutePath = validateDir(dirPath);
+  } catch (err) {
+    console.log(chalk.red(err.message));
+    process.exitCode = 1;
+    return;
+  }
+
+  const pairs = getSyncPairs().filter(p => p.localPath === absolutePath);
+  if (pairs.length === 0) {
+    console.log(chalk.yellow(`No sync pairs for ${absolutePath}.`));
+    console.log(chalk.gray('Use `pal sync <path> <pal>` to create one.'));
+    return;
+  }
+
+  const friends = getFriends();
+  console.log('');
+  console.log(chalk.cyan.bold(`Sync Status: ${absolutePath}`));
+  console.log('');
+
+  const statusCached = pairs.length === 1 ? getSyncManifest(pairs[0].id) : null;
+  const currentManifest = await buildManifest(absolutePath, statusCached);
+  const currentMap = manifestToMap(currentManifest);
+
+  for (const pair of pairs) {
+    const pal = friends.find(f => f.id === pair.palId);
+    const palName = pal?.name || pair.palId;
+    const lastManifest = getSyncManifest(pair.id);
+
+    console.log(`  ${chalk.yellow(palName)} (${pair.status})`);
+
+    if (!lastManifest) {
+      console.log(chalk.gray('    No previous sync. All files will be synced.'));
+      console.log(`    ${chalk.white(`${currentManifest.length} file(s) to push`)}`);
+    } else {
+      const lastMap = manifestToMap(lastManifest);
+      const diff = diffManifests(lastMap, currentMap);
+      const total = diff.added.length + diff.modified.length + diff.deleted.length;
+
+      if (total === 0) {
+        console.log(chalk.green('    In sync. No local changes.'));
+      } else {
+        console.log(`    ${chalk.green(`+${diff.added.length}`)} added  ${chalk.yellow(`~${diff.modified.length}`)} modified  ${chalk.red(`-${diff.deleted.length}`)} deleted`);
+        if (diff.added.length <= 5) {
+          for (const a of diff.added) console.log(chalk.green(`      + ${a.relativePath}`));
+        }
+        if (diff.modified.length <= 5) {
+          for (const m of diff.modified) console.log(chalk.yellow(`      ~ ${m.relativePath}`));
+        }
+        if (diff.deleted.length <= 5) {
+          for (const d of diff.deleted) console.log(chalk.red(`      - ${d.relativePath}`));
+        }
+      }
+    }
+
+    const history = getSyncHistory(pair.id);
+    if (history.length > 0) {
+      console.log(chalk.gray(`    Last ${Math.min(history.length, 3)} syncs:`));
+      for (const h of history.slice(0, 3)) {
+        const dir = h.direction === 'push' ? chalk.blue('PUSH') :
+                    h.direction === 'pull' ? chalk.magenta('PULL') :
+                    chalk.cyan('SYNC');
+        const changes = [];
+        if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
+        if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
+        if (h.filesDeleted) changes.push(chalk.red(`-${h.filesDeleted}`));
+        if (h.conflicts) changes.push(chalk.magenta(`!${h.conflicts}`));
+        console.log(chalk.gray(`      ${h.timestamp}  ${dir}  ${changes.join(' ')}${h.auto ? chalk.gray(' [auto]') : ''}`));
+      }
+    }
+    console.log('');
+  }
+}
+
+// --- pal sync remove <id> ---
+
+function removePair(id) {
+  const pairs = getSyncPairs();
+  const pair = pairs.find(p => p.id === id);
+  if (!pair) {
+    console.log(chalk.red(`Sync pair '${id}' not found.`));
+    process.exitCode = 1;
+    return;
+  }
+  removeSyncPair(id);
+  console.log(chalk.green(`Removed sync pair ${id}.`));
+}
+
+function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h)$/);
+  if (!match) return null;
+  const [, num, unit] = match;
+  const multipliers = { s: 1000, m: 60000, h: 3600000 };
+  return parseInt(num, 10) * multipliers[unit];
+}
+
+function formatSyncBytes(b) {
+  if (!b) return '0 B';
+  if (b < 1024) return b + ' B';
+  if (b < 1048576) return (b / 1024).toFixed(1) + ' KB';
+  if (b < 1073741824) return (b / 1048576).toFixed(1) + ' MB';
+  return (b / 1073741824).toFixed(2) + ' GB';
+}
+
+// --- Command registration ---
+
+export default function syncCommand(program) {
+  const cmd = program
+    .command('sync')
+    .description('sync directories with pals (rsync-like P2P sync)');
+
+  // Default: pal sync <path> <pal> — bi-directional
+  const defaultSync = cmd
+    .command('start <path> <pal>')
+    .description('bi-directional sync with a pal (default)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
+        console.log(chalk.red('Error: path cannot be empty.'));
+        process.exitCode = 1;
+        return;
+      }
+      await biSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(defaultSync);
+
+  const pushCmd = cmd
+    .command('push <path> <pal>')
+    .description('push local changes to a pal (one-way)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
+        console.log(chalk.red('Error: path cannot be empty.'));
+        process.exitCode = 1;
+        return;
+      }
+      await pushSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(pushCmd);
+
+  const pullCmd = cmd
+    .command('pull <path> <pal>')
+    .description('pull changes from a pal (one-way)')
+    .action(async (syncPath, pal, cliOpts) => {
+      if (!syncPath?.trim()) {
+        console.log(chalk.red('Error: path cannot be empty.'));
+        process.exitCode = 1;
+        return;
+      }
+      await pullSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(pullCmd);
+
+  const watchCmd = cmd
+    .command('watch <path> <pal>')
+    .description('watch directory and auto-sync on changes')
+    .action(async (syncPath, pal, cliOpts) => {
+      await watchSync(syncPath, pal, cliOpts);
+    });
+  addSyncFlagsToCommand(watchCmd);
+
+  cmd
+    .command('status [path]')
+    .description('show sync status and changes since last sync')
+    .action((syncPath) => {
+      syncStatus(syncPath);
+    });
+
+  cmd
+    .command('list')
+    .description('list all sync pairs')
+    .action(() => {
+      syncStatus();
+    });
+
+  cmd
+    .command('remove <id>')
+    .description('remove a sync pair')
+    .action((id) => {
+      removePair(id);
+    });
+
+  cmd
+    .command('history [pairId]')
+    .description('view sync history')
+    .action((pairId) => {
+      const pairs = getSyncPairs();
+      if (pairs.length === 0) {
+        console.log(chalk.gray('No sync pairs configured.'));
+        return;
+      }
+
+      const friends = getFriends();
+      const targetPairs = pairId ? pairs.filter(p => p.id === pairId) : pairs;
+      if (targetPairs.length === 0) {
+        console.log(chalk.red(`Sync pair '${pairId}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+
+      console.log('');
+      console.log(chalk.cyan.bold('Sync History'));
+      console.log('');
+
+      for (const pair of targetPairs) {
+        const pal = friends.find(f => f.id === pair.palId);
+        const palName = pal?.name || pair.palId;
+        console.log(`  ${chalk.white(pair.localPath)} ${chalk.gray('->')} ${chalk.yellow(palName)}`);
+        console.log(`  ${chalk.gray(`ID: ${pair.id}`)}`);
+
+        const history = getSyncHistory(pair.id);
+        if (history.length === 0) {
+          console.log(chalk.gray('    No history yet.'));
+        } else {
+          for (const h of history) {
+            const dir = h.direction === 'push' ? chalk.blue('PUSH') :
+                        h.direction === 'pull' ? chalk.magenta('PULL') :
+                        chalk.cyan('SYNC');
+            const changes = [];
+            if (h.filesAdded) changes.push(chalk.green(`+${h.filesAdded}`));
+            if (h.filesModified) changes.push(chalk.yellow(`~${h.filesModified}`));
+            if (h.filesDeleted) changes.push(chalk.red(`-${h.filesDeleted}`));
+            if (h.conflicts) changes.push(chalk.magenta(`!${h.conflicts}`));
+            if (h.totalFiles) changes.push(chalk.gray(`(${h.totalFiles} total)`));
+            console.log(`    ${chalk.gray(h.timestamp)}  ${dir}  ${changes.join(' ')}${h.auto ? chalk.gray(' [auto]') : ''}`);
+          }
+        }
+        console.log('');
+      }
+    });
+
+  cmd
+    .command('diff <localPath> <remotePath>')
+    .description('compare local and remote folders, show what needs to transfer')
+    .option('--json', 'Output as JSON')
+    .action(async (localPath, remotePath, cmdOpts) => {
+      try {
+        console.log(chalk.blue('Building local manifest...'));
+        const localManifest = buildDiffManifest(localPath);
+        console.log(chalk.blue('Building remote manifest...'));
+        const remoteManifest = buildDiffManifest(remotePath);
+
+        const diff = diffFileManifests(localManifest, remoteManifest);
+        const summary = diffSummary(diff);
+
+        if (cmdOpts.json) {
+          console.log(JSON.stringify({ diff, summary }, null, 2));
+          return;
+        }
+
+        console.log();
+        if (diff.added.length > 0) {
+          console.log(chalk.green(`  + ${diff.added.length} new files`));
+          diff.added.forEach(f => console.log(chalk.green(`    + ${f.path} (${formatSyncBytes(f.size)})`)));
+        }
+        if (diff.modified.length > 0) {
+          console.log(chalk.yellow(`  ~ ${diff.modified.length} modified files`));
+          diff.modified.forEach(f => console.log(chalk.yellow(`    ~ ${f.path} (${formatSyncBytes(f.size)})`)));
+        }
+        if (diff.deleted.length > 0) {
+          console.log(chalk.red(`  - ${diff.deleted.length} deleted files`));
+          diff.deleted.forEach(f => console.log(chalk.red(`    - ${f.path}`)));
+        }
+        if (diff.unchanged.length > 0) {
+          console.log(chalk.gray(`  = ${diff.unchanged.length} unchanged files`));
+        }
+
+        console.log();
+        console.log(chalk.white(`  Transfer needed: ${formatSyncBytes(summary.transferBytes)} (${summary.addedCount + summary.modifiedCount} files)`));
+        console.log(chalk.gray(`  Skipping: ${summary.skippedFiles} files already up to date`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // --- pal sync profile save/list/use ---
+  const profileCmd = cmd.command('profile').description('manage sync flag profiles');
+
+  profileCmd
+    .command('save <name>')
+    .description('save current flags as a named profile')
+    .action((name, _opts, profileCommand) => {
+      // Collect flags from parent command context
+      const parentOpts = profileCommand.parent?.parent?.opts() || {};
+      const profiles = config.get('syncProfiles') || {};
+      const profile = {};
+      for (const key of ['exclude', 'include', 'delete', 'checksum', 'sizeOnly', 'update',
+        'ignoreExisting', 'backup', 'compress', 'bandwidthLimit', 'archive']) {
+        if (parentOpts[key] !== undefined) profile[key] = parentOpts[key];
+      }
+      profiles[name] = profile;
+      config.set('syncProfiles', profiles);
+      console.log(chalk.green(`Profile '${name}' saved.`));
+      if (Object.keys(profile).length === 0) {
+        console.log(chalk.gray('  (empty profile — use with sync flags to save them)'));
+      } else {
+        for (const [k, v] of Object.entries(profile)) {
+          console.log(chalk.gray(`  ${k}: ${JSON.stringify(v)}`));
+        }
+      }
+    });
+
+  profileCmd
+    .command('list')
+    .description('list saved profiles')
+    .action(() => {
+      const profiles = config.get('syncProfiles') || {};
+      const names = Object.keys(profiles);
+      if (names.length === 0) {
+        console.log(chalk.gray('No saved profiles. Use `pal sync profile save <name>` to create one.'));
+        return;
+      }
+      console.log('');
+      console.log(chalk.cyan.bold('Sync Profiles'));
+      for (const name of names) {
+        const p = profiles[name];
+        const flags = Object.entries(p).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(', ');
+        console.log(`  ${chalk.white(name)}: ${chalk.gray(flags || '(empty)')}`);
+      }
+      console.log('');
+    });
+
+  profileCmd
+    .command('use <name>')
+    .description('show flags for a profile (use with eval or copy)')
+    .action((name) => {
+      const profiles = config.get('syncProfiles') || {};
+      const profile = profiles[name];
+      if (!profile) {
+        console.log(chalk.red(`Profile '${name}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+      const flags = [];
+      if (profile.exclude) {
+        const arr = Array.isArray(profile.exclude) ? profile.exclude : [profile.exclude];
+        arr.forEach(p => flags.push(`--exclude "${p}"`));
+      }
+      if (profile.include) {
+        const arr = Array.isArray(profile.include) ? profile.include : [profile.include];
+        arr.forEach(p => flags.push(`--include "${p}"`));
+      }
+      if (profile.delete) flags.push('--delete');
+      if (profile.checksum) flags.push('--checksum');
+      if (profile.sizeOnly) flags.push('--size-only');
+      if (profile.update) flags.push('--update');
+      if (profile.ignoreExisting) flags.push('--ignore-existing');
+      if (profile.backup) flags.push('--backup');
+      if (profile.compress) flags.push('--compress');
+      if (profile.bandwidthLimit) flags.push(`--bandwidth-limit ${profile.bandwidthLimit}`);
+      if (profile.archive) flags.push('--archive');
+
+      console.log(flags.join(' ') || '(no flags)');
+    });
+
+  profileCmd
+    .command('delete <name>')
+    .description('delete a saved profile')
+    .action((name) => {
+      const profiles = config.get('syncProfiles') || {};
+      if (!profiles[name]) {
+        console.log(chalk.red(`Profile '${name}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+      delete profiles[name];
+      config.set('syncProfiles', profiles);
+      console.log(chalk.green(`Profile '${name}' deleted.`));
+    });
+
+  // --- pal sync schedule <path> <pal> --every <interval> ---
+  cmd
+    .command('schedule <path> <pal>')
+    .description('background sync at intervals')
+    .requiredOption('--every <interval>', 'sync interval (e.g., 5m, 1h, 30s)')
+    .action(async (syncPath, pal, schedOpts) => {
+      let absolutePath, palObj, keyPair;
+      try {
+        absolutePath = validateDir(syncPath);
+        palObj = findPal(pal);
+        getIdentity();
+        keyPair = getKeyPair();
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+        return;
+      }
+
+      const intervalMs = parseInterval(schedOpts.every);
+      if (!intervalMs || intervalMs < 5000) {
+        console.log(chalk.red('Invalid interval. Minimum: 5s. Examples: 30s, 5m, 1h'));
+        process.exitCode = 1;
+        return;
+      }
+
+      const palHandle = palObj.handle || palObj.name;
+      const palId = palObj.id || palObj.publicKey;
+      const pair = addSyncPair(absolutePath, palId, `sync:${palHandle}`);
+
+      registerSyncHandlers();
+
+      console.log(chalk.blue(`Scheduled sync: ${absolutePath} -> ${palObj.name} every ${schedOpts.every}`));
+      console.log(chalk.gray('Press Ctrl+C to stop.'));
+
+      const doSync = async () => {
+        try {
+          const transport = await selectSyncTransport(palId, { peerHandle: palHandle });
+          const lastManifest = getSyncManifest(pair.id);
+          const session = new SyncSession({
+            localPath: absolutePath,
+            peerPK: palId,
+            transport,
+            keyPair,
+            syncPairId: pair.id,
+          });
+          await session.start(lastManifest);
+          const manifest = session.localManifest;
+          saveSyncManifest(pair.id, manifest);
+          updateSyncPair(pair.id, {
+            lastSync: new Date().toISOString(),
+            status: 'synced',
+            lastDirection: 'push',
+          });
+          addSyncHistoryEntry(pair.id, {
+            direction: 'push',
+            totalFiles: manifest.length,
+            auto: true,
+          });
+          session.finish();
+          console.log(chalk.green(`  Synced at ${new Date().toLocaleTimeString()} (${manifest.length} files)`));
+        } catch (err) {
+          console.log(chalk.yellow(`  Sync failed: ${err.message}`));
+        }
+      };
+
+      doSync();
+      const timer = setInterval(doSync, intervalMs);
+      process.on('SIGINT', () => { clearInterval(timer); process.exit(0); });
+    });
+
+  cmd.addHelpText('after', `
+${chalk.cyan('Examples:')}
+  $ pal sync start ./project alice       Bi-directional sync with alice
+  $ pal sync push ./project alice        Push local changes to alice
+  $ pal sync pull ./project alice        Pull alice's changes locally
+  $ pal sync watch ./project alice       Watch and auto-sync on changes
+  $ pal sync status ./project            Show what changed since last sync
+  $ pal sync status                      Show all sync pairs
+
+${chalk.cyan('rsync-like flags:')}
+  $ pal sync push ./project alice --dry-run          Preview without applying
+  $ pal sync push ./project alice --exclude "*.log"  Skip log files
+  $ pal sync push ./project alice --delete           Remove files not in source
+  $ pal sync push ./project alice --compress          Compress transfer
+  $ pal sync push ./project alice --progress          Show progress
+  $ pal sync push ./project alice --archive           --recursive --checksum --delete
+  $ pal sync push ./project alice --backup            Create .bak before overwriting
+  $ pal sync push ./project alice --bandwidth-limit 500  Throttle to 500 KB/s
+
+${chalk.cyan('How it works:')}
+  1. Sync uses PAL/1.0 protocol over LAN (TCP:7474) or WebRTC (internet).
+  2. No discovery server required for LAN sync.
+  3. Manifests are signed and encrypted (Ed25519 + XChaCha20-Poly1305).
+  4. Conflicts create ${chalk.magenta('.sync-conflict')} copies — no data loss.
+  5. ${chalk.white('watch')} monitors your directory and auto-syncs on changes.
+`);
+}