@prnv/tuck 1.2.0 → 1.3.0

package/dist/index.js

@@ -351,6 +351,22 @@ var init_table = __esm({
   }
 });
 
+// src/ui/progress.ts
+import chalk6 from "chalk";
+import ora2 from "ora";
+var ICONS;
+var init_progress = __esm({
+  "src/ui/progress.ts"() {
+    "use strict";
+    ICONS = {
+      pending: chalk6.dim("\u25CB"),
+      in_progress: chalk6.cyan("\u25CF"),
+      completed: chalk6.green("\u2713"),
+      error: chalk6.red("\u2717")
+    };
+  }
+});
+
 // src/ui/index.ts
 var init_ui = __esm({
   "src/ui/index.ts"() {
@@ -360,17 +376,28 @@ var init_ui = __esm({
     init_prompts();
     init_spinner();
     init_table();
+    init_progress();
   }
 });
 
 // src/constants.ts
 import { homedir } from "os";
-import { join } from "path";
-var VERSION, DESCRIPTION, HOME_DIR, DEFAULT_TUCK_DIR, MANIFEST_FILE, CONFIG_FILE, BACKUP_DIR, FILES_DIR, CATEGORIES, COMMON_DOTFILES;
+import { join, dirname } from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+var __dirname, packageJsonPath, VERSION_VALUE, VERSION, DESCRIPTION, HOME_DIR, DEFAULT_TUCK_DIR, MANIFEST_FILE, CONFIG_FILE, BACKUP_DIR, FILES_DIR, CATEGORIES;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    VERSION = "0.1.0";
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    packageJsonPath = join(__dirname, "..", "package.json");
+    VERSION_VALUE = "1.0.0";
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      VERSION_VALUE = pkg.version;
+    } catch {
+    }
+    VERSION = VERSION_VALUE;
     DESCRIPTION = "Modern dotfiles manager with a beautiful CLI";
     HOME_DIR = homedir();
     DEFAULT_TUCK_DIR = join(HOME_DIR, ".tuck");
@@ -430,23 +457,12 @@ var init_constants = __esm({
         icon: "-"
       }
     };
-    COMMON_DOTFILES = [
-      { path: "~/.zshrc", category: "shell" },
-      { path: "~/.bashrc", category: "shell" },
-      { path: "~/.bash_profile", category: "shell" },
-      { path: "~/.gitconfig", category: "git" },
-      { path: "~/.config/nvim", category: "editors" },
-      { path: "~/.vimrc", category: "editors" },
-      { path: "~/.tmux.conf", category: "terminal" },
-      { path: "~/.ssh/config", category: "ssh" },
-      { path: "~/.config/starship.toml", category: "terminal" }
-    ];
   }
 });
 
 // src/lib/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join2, basename, dirname, relative, isAbsolute, resolve } from "path";
+import { join as join2, basename, dirname as dirname2, relative, isAbsolute, resolve, sep } from "path";
 import { stat, access } from "fs/promises";
 import { constants } from "fs";
 var expandPath, collapsePath, getTuckDir, getManifestPath, getConfigPath, getFilesDir, getCategoryDir, getDestinationPath, getRelativeDestination, sanitizeFilename, detectCategory, pathExists, isDirectory, isPathWithinHome, validateSafeSourcePath, generateFileId;
@@ -532,7 +548,7 @@ var init_paths = __esm({
       const expandedPath = expandPath(path);
       const normalizedPath = resolve(expandedPath);
       const normalizedHome = resolve(home);
-      return normalizedPath.startsWith(normalizedHome + "/") || normalizedPath === normalizedHome;
+      return normalizedPath.startsWith(normalizedHome + sep) || normalizedPath === normalizedHome;
     };
     validateSafeSourcePath = (source) => {
       if (isAbsolute(source) && !source.startsWith(homedir2())) {
@@ -629,7 +645,7 @@ var init_config_schema = __esm({
 });
 
 // src/errors.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 var TuckError, NotInitializedError, AlreadyInitializedError, FileNotFoundError, FileNotTrackedError, FileAlreadyTrackedError, GitError, ConfigError, ManifestError, PermissionError, GitHubCliError, BackupError, handleError;
 var init_errors = __esm({
   "src/errors.ts"() {
@@ -726,22 +742,22 @@ var init_errors = __esm({
     };
     handleError = (error) => {
       if (error instanceof TuckError) {
-        console.error(chalk6.red("x"), error.message);
+        console.error(chalk7.red("x"), error.message);
         if (error.suggestions && error.suggestions.length > 0) {
           console.error();
-          console.error(chalk6.dim("Suggestions:"));
-          error.suggestions.forEach((s) => console.error(chalk6.dim(`  \u2192 ${s}`)));
+          console.error(chalk7.dim("Suggestions:"));
+          error.suggestions.forEach((s) => console.error(chalk7.dim(`  \u2192 ${s}`)));
         }
         process.exit(1);
       }
       if (error instanceof Error) {
-        console.error(chalk6.red("x"), "An unexpected error occurred:", error.message);
+        console.error(chalk7.red("x"), "An unexpected error occurred:", error.message);
         if (process.env.DEBUG) {
           console.error(error.stack);
         }
         process.exit(1);
       }
-      console.error(chalk6.red("x"), "An unknown error occurred");
+      console.error(chalk7.red("x"), "An unknown error occurred");
       process.exit(1);
     };
   }
@@ -1160,9 +1176,9 @@ var init_git = __esm({
         const remote = options?.remote || "origin";
         const branch = options?.branch;
         if (branch) {
-          await git.push([remote, branch, ...args]);
+          await git.push([...args, remote, branch]);
         } else {
-          await git.push([remote, ...args]);
+          await git.push([...args, remote]);
         }
       } catch (error) {
         throw new GitError("Failed to push", String(error));
@@ -1234,9 +1250,15 @@ var init_git = __esm({
       try {
         const git = createGit(dir);
         const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
-        return branch;
-      } catch (error) {
-        throw new GitError("Failed to get current branch", String(error));
+        return branch.trim();
+      } catch {
+        try {
+          const git = createGit(dir);
+          const ref = await git.raw(["symbolic-ref", "--short", "HEAD"]);
+          return ref.trim();
+        } catch {
+          return "main";
+        }
       }
     };
     hasRemote = async (dir, name = "origin") => {
@@ -1478,9 +1500,10 @@ var init_github = __esm({
 
 // src/lib/files.ts
 import { createHash } from "crypto";
-import { readFile as readFile5, stat as stat4, readdir as readdir3, copyFile, symlink, unlink, rm as rm3 } from "fs/promises";
-import { copy as copy3, ensureDir as ensureDir3 } from "fs-extra";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFile as readFile4, stat as stat4, lstat, readdir as readdir3, copyFile, symlink, unlink, rm as rm2 } from "fs/promises";
+import { copy as copy2, ensureDir as ensureDir2 } from "fs-extra";
+import { join as join6, dirname as dirname4 } from "path";
+import { constants as constants2 } from "fs";
 var getFileChecksum, getFileInfo, getDirectoryFiles, getDirectoryFileCount, copyFileOrDir, createSymlink, deleteFileOrDir;
 var init_files = __esm({
   "src/lib/files.ts"() {
@@ -1493,12 +1516,12 @@ var init_files = __esm({
         const files = await getDirectoryFiles(expandedPath);
         const hashes = [];
         for (const file of files) {
-          const content2 = await readFile5(file);
+          const content2 = await readFile4(file);
           hashes.push(createHash("sha256").update(content2).digest("hex"));
         }
         return createHash("sha256").update(hashes.join("")).digest("hex");
       }
-      const content = await readFile5(expandedPath);
+      const content = await readFile4(expandedPath);
       return createHash("sha256").update(content).digest("hex");
     };
     getFileInfo = async (filepath) => {
@@ -1524,14 +1547,27 @@ var init_files = __esm({
     getDirectoryFiles = async (dirpath) => {
       const expandedPath = expandPath(dirpath);
       const files = [];
-      const entries = await readdir3(expandedPath, { withFileTypes: true });
+      let entries;
+      try {
+        entries = await readdir3(expandedPath, { withFileTypes: true });
+      } catch (error) {
+        return files;
+      }
       for (const entry of entries) {
-        const entryPath = join7(expandedPath, entry.name);
-        if (entry.isDirectory()) {
-          const subFiles = await getDirectoryFiles(entryPath);
-          files.push(...subFiles);
-        } else if (entry.isFile()) {
-          files.push(entryPath);
+        const entryPath = join6(expandedPath, entry.name);
+        try {
+          const lstats = await lstat(entryPath);
+          if (lstats.isSymbolicLink()) {
+            continue;
+          }
+          if (entry.isDirectory()) {
+            const subFiles = await getDirectoryFiles(entryPath);
+            files.push(...subFiles);
+          } else if (entry.isFile()) {
+            files.push(entryPath);
+          }
+        } catch {
+          continue;
         }
       }
       return files.sort();
@@ -1546,11 +1582,12 @@ var init_files = __esm({
       if (!await pathExists(expandedSource)) {
         throw new FileNotFoundError(source);
       }
-      await ensureDir3(dirname3(expandedDest));
+      await ensureDir2(dirname4(expandedDest));
       const sourceIsDir = await isDirectory(expandedSource);
       try {
+        const shouldOverwrite = options?.overwrite ?? true;
         if (sourceIsDir) {
-          await copy3(expandedSource, expandedDest, { overwrite: options?.overwrite ?? true });
+          await copy2(expandedSource, expandedDest, { overwrite: shouldOverwrite });
           const fileCount = await getDirectoryFileCount(expandedDest);
           const files = await getDirectoryFiles(expandedDest);
           let totalSize = 0;
@@ -1560,7 +1597,8 @@ var init_files = __esm({
           }
           return { source: expandedSource, destination: expandedDest, fileCount, totalSize };
         } else {
-          await copyFile(expandedSource, expandedDest);
+          const copyFlags = shouldOverwrite ? 0 : constants2.COPYFILE_EXCL;
+          await copyFile(expandedSource, expandedDest, copyFlags);
           const stats = await stat4(expandedDest);
           return { source: expandedSource, destination: expandedDest, fileCount: 1, totalSize: stats.size };
         }
@@ -1574,7 +1612,7 @@ var init_files = __esm({
       if (!await pathExists(expandedTarget)) {
         throw new FileNotFoundError(target);
       }
-      await ensureDir3(dirname3(expandedLink));
+      await ensureDir2(dirname4(expandedLink));
       if (options?.overwrite && await pathExists(expandedLink)) {
         await unlink(expandedLink);
       }
@@ -1591,7 +1629,7 @@ var init_files = __esm({
       }
       try {
         if (await isDirectory(expandedPath)) {
-          await rm3(expandedPath, { recursive: true });
+          await rm2(expandedPath, { recursive: true });
         } else {
           await unlink(expandedPath);
         }
@@ -1602,235 +1640,620 @@ var init_files = __esm({
   }
 });
 
-// src/commands/add.ts
-var add_exports = {};
-__export(add_exports, {
-  addCommand: () => addCommand,
-  addFilesFromPaths: () => addFilesFromPaths
+// src/lib/backup.ts
+import { join as join7 } from "path";
+import { copy as copy3, ensureDir as ensureDir4, pathExists as pathExists3 } from "fs-extra";
+var getBackupDir, formatDateForBackup, getTimestampedBackupDir, createBackup;
+var init_backup = __esm({
+  "src/lib/backup.ts"() {
+    "use strict";
+    init_constants();
+    init_paths();
+    getBackupDir = () => {
+      return expandPath(BACKUP_DIR);
+    };
+    formatDateForBackup = (date) => {
+      return date.toISOString().slice(0, 10);
+    };
+    getTimestampedBackupDir = (date) => {
+      const backupRoot = getBackupDir();
+      const timestamp = formatDateForBackup(date);
+      return join7(backupRoot, timestamp);
+    };
+    createBackup = async (sourcePath, customBackupDir) => {
+      const expandedSource = expandPath(sourcePath);
+      const date = /* @__PURE__ */ new Date();
+      if (!await pathExists(expandedSource)) {
+        throw new Error(`Source path does not exist: ${sourcePath}`);
+      }
+      const backupRoot = customBackupDir ? expandPath(customBackupDir) : getTimestampedBackupDir(date);
+      await ensureDir4(backupRoot);
+      const collapsed = collapsePath(expandedSource);
+      const backupName = collapsed.replace(/^~\//, "").replace(/\//g, "_").replace(/^\./, "dot-");
+      const timestamp = date.toISOString().replace(/[:.]/g, "-").slice(11, 19);
+      const backupPath = join7(backupRoot, `${backupName}_${timestamp}`);
+      await copy3(expandedSource, backupPath, { overwrite: true });
+      return {
+        originalPath: expandedSource,
+        backupPath,
+        date
+      };
+    };
+  }
 });
-import { Command as Command2 } from "commander";
-import { basename as basename3 } from "path";
-import chalk7 from "chalk";
-var PRIVATE_KEY_PATTERNS, SENSITIVE_FILE_PATTERNS, isPrivateKey, isSensitiveFile, validateAndPrepareFiles, addFiles, runInteractiveAdd, addFilesFromPaths, runAdd, addCommand;
-var init_add = __esm({
-  "src/commands/add.ts"() {
+
+// src/lib/hooks.ts
+import { exec } from "child_process";
+import { promisify as promisify2 } from "util";
+import chalk9 from "chalk";
+var execAsync, runHook, runPreSyncHook, runPostSyncHook, runPreRestoreHook, runPostRestoreHook;
+var init_hooks = __esm({
+  "src/lib/hooks.ts"() {
+    "use strict";
+    init_config();
+    init_logger();
+    init_prompts();
+    execAsync = promisify2(exec);
+    runHook = async (hookType, tuckDir, options) => {
+      if (options?.skipHooks) {
+        return { success: true, skipped: true };
+      }
+      const config = await loadConfig(tuckDir);
+      const command = config.hooks[hookType];
+      if (!command) {
+        return { success: true };
+      }
+      if (!options?.trustHooks) {
+        console.log();
+        console.log(chalk9.yellow.bold("WARNING: Hook Execution"));
+        console.log(chalk9.dim("\u2500".repeat(50)));
+        console.log(chalk9.white(`Hook type: ${chalk9.cyan(hookType)}`));
+        console.log(chalk9.white("Command:"));
+        console.log(chalk9.red(`  ${command}`));
+        console.log(chalk9.dim("\u2500".repeat(50)));
+        console.log(
+          chalk9.yellow(
+            "SECURITY: Hooks can execute arbitrary commands on your system."
+          )
+        );
+        console.log(
+          chalk9.yellow(
+            "Only proceed if you trust the source of this configuration."
+          )
+        );
+        console.log();
+        const confirmed = await prompts.confirm(
+          "Execute this hook?",
+          false
+          // Default to NO for safety
+        );
+        if (!confirmed) {
+          logger.warning(`Hook ${hookType} skipped by user`);
+          return { success: true, skipped: true };
+        }
+      }
+      if (!options?.silent) {
+        logger.dim(`Running ${hookType} hook...`);
+      }
+      try {
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: tuckDir,
+          timeout: 3e4,
+          // 30 second timeout
+          env: {
+            ...process.env,
+            TUCK_DIR: tuckDir,
+            TUCK_HOOK: hookType
+          }
+        });
+        if (stdout && !options?.silent) {
+          logger.dim(stdout.trim());
+        }
+        if (stderr && !options?.silent) {
+          logger.warning(stderr.trim());
+        }
+        return { success: true, output: stdout };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!options?.silent) {
+          logger.error(`Hook ${hookType} failed: ${errorMessage}`);
+        }
+        return { success: false, error: errorMessage };
+      }
+    };
+    runPreSyncHook = async (tuckDir, options) => {
+      return runHook("preSync", tuckDir, options);
+    };
+    runPostSyncHook = async (tuckDir, options) => {
+      return runHook("postSync", tuckDir, options);
+    };
+    runPreRestoreHook = async (tuckDir, options) => {
+      return runHook("preRestore", tuckDir, options);
+    };
+    runPostRestoreHook = async (tuckDir, options) => {
+      return runHook("postRestore", tuckDir, options);
+    };
+  }
+});
+
+// src/commands/restore.ts
+var restore_exports = {};
+__export(restore_exports, {
+  restoreCommand: () => restoreCommand,
+  runRestore: () => runRestore
+});
+import { Command } from "commander";
+import chalk10 from "chalk";
+import { join as join8 } from "path";
+import { chmod, stat as stat5 } from "fs/promises";
+var fixSSHPermissions, fixGPGPermissions, prepareFilesToRestore, restoreFiles, runInteractiveRestore, runRestore, runRestoreCommand, restoreCommand;
+var init_restore = __esm({
+  "src/commands/restore.ts"() {
     "use strict";
     init_ui();
     init_paths();
-    init_config();
     init_manifest();
+    init_config();
     init_files();
+    init_backup();
+    init_hooks();
     init_errors();
     init_constants();
-    PRIVATE_KEY_PATTERNS = [
-      /^id_rsa$/,
-      /^id_dsa$/,
-      /^id_ecdsa$/,
-      /^id_ed25519$/,
-      /^id_.*$/,
-      // Any id_ file without .pub
-      /\.pem$/,
-      /\.key$/,
-      /^.*_key$/
-      // aws_key, github_key, etc.
-    ];
-    SENSITIVE_FILE_PATTERNS = [
-      /^\.netrc$/,
-      /^\.aws\/credentials$/,
-      /^\.docker\/config\.json$/,
-      /^\.npmrc$/,
-      // May contain tokens
-      /^\.pypirc$/,
-      /^\.kube\/config$/,
-      /^\.ssh\/config$/,
-      /^\.gnupg\//,
-      /credentials/i,
-      /secrets?/i,
-      /tokens?\.json$/i,
-      /\.env$/,
-      /\.env\./
-    ];
-    isPrivateKey = (path) => {
-      const name = basename3(path);
-      if (path.includes(".ssh/") && !name.endsWith(".pub")) {
-        for (const pattern of PRIVATE_KEY_PATTERNS) {
-          if (pattern.test(name)) {
-            return true;
-          }
-        }
+    fixSSHPermissions = async (path) => {
+      const expandedPath = expandPath(path);
+      if (!path.includes(".ssh/") && !path.endsWith(".ssh")) {
+        return;
       }
-      if (name.endsWith(".pem") || name.endsWith(".key")) {
-        return true;
+      try {
+        const stats = await stat5(expandedPath);
+        if (stats.isDirectory()) {
+          await chmod(expandedPath, 448);
+        } else {
+          await chmod(expandedPath, 384);
+        }
+      } catch {
       }
-      return false;
     };
-    isSensitiveFile = (path) => {
-      const pathToTest = path.startsWith("~/") ? path.slice(2) : path;
-      for (const pattern of SENSITIVE_FILE_PATTERNS) {
-        if (pattern.test(pathToTest)) {
-          return true;
+    fixGPGPermissions = async (path) => {
+      const expandedPath = expandPath(path);
+      if (!path.includes(".gnupg/") && !path.endsWith(".gnupg")) {
+        return;
+      }
+      try {
+        const stats = await stat5(expandedPath);
+        if (stats.isDirectory()) {
+          await chmod(expandedPath, 448);
+        } else {
+          await chmod(expandedPath, 384);
         }
+      } catch {
       }
-      return false;
     };
-    validateAndPrepareFiles = async (paths, tuckDir, options) => {
-      const filesToAdd = [];
-      for (const path of paths) {
-        const expandedPath = expandPath(path);
-        const collapsedPath = collapsePath(expandedPath);
-        if (isPrivateKey(collapsedPath)) {
-          throw new Error(
-            `Cannot track private key: ${path}
-Private keys should NEVER be committed to a repository.
-If you need to backup SSH keys, use a secure password manager.`
-          );
-        }
-        if (!await pathExists(expandedPath)) {
-          throw new FileNotFoundError(path);
+    prepareFilesToRestore = async (tuckDir, paths) => {
+      const allFiles = await getAllTrackedFiles(tuckDir);
+      const filesToRestore = [];
+      if (paths && paths.length > 0) {
+        for (const path of paths) {
+          const expandedPath = expandPath(path);
+          const collapsedPath = collapsePath(expandedPath);
+          const tracked = await getTrackedFileBySource(tuckDir, collapsedPath);
+          if (!tracked) {
+            throw new FileNotFoundError(`Not tracked: ${path}`);
+          }
+          filesToRestore.push({
+            id: tracked.id,
+            source: tracked.file.source,
+            destination: join8(tuckDir, tracked.file.destination),
+            category: tracked.file.category,
+            existsAtTarget: await pathExists(expandedPath)
+          });
         }
-        if (await isFileTracked(tuckDir, collapsedPath)) {
-          throw new FileAlreadyTrackedError(path);
+      } else {
+        for (const [id, file] of Object.entries(allFiles)) {
+          const targetPath = expandPath(file.source);
+          filesToRestore.push({
+            id,
+            source: file.source,
+            destination: join8(tuckDir, file.destination),
+            category: file.category,
+            existsAtTarget: await pathExists(targetPath)
+          });
         }
-        const isDir = await isDirectory(expandedPath);
-        const fileCount = isDir ? await getDirectoryFileCount(expandedPath) : 1;
-        const category = options.category || detectCategory(expandedPath);
-        const filename = options.name || sanitizeFilename(expandedPath);
-        const destination = getDestinationPath(tuckDir, category, filename);
-        const sensitive = isSensitiveFile(collapsedPath);
-        filesToAdd.push({
-          source: collapsedPath,
-          destination,
-          category,
-          filename,
-          isDir,
-          fileCount,
-          sensitive
-        });
       }
-      return filesToAdd;
+      return filesToRestore;
     };
-    addFiles = async (filesToAdd, tuckDir, options) => {
+    restoreFiles = async (tuckDir, files, options) => {
       const config = await loadConfig(tuckDir);
-      const strategy = options.symlink ? "symlink" : config.files.strategy || "copy";
-      for (const file of filesToAdd) {
-        const expandedSource = expandPath(file.source);
-        await withSpinner(`Copying ${file.source}...`, async () => {
-          await copyFileOrDir(expandedSource, file.destination, { overwrite: true });
-        });
-        const checksum = await getFileChecksum(file.destination);
-        const info = await getFileInfo(expandedSource);
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const id = generateFileId(file.source);
-        await addFileToManifest(tuckDir, id, {
-          source: file.source,
-          destination: getRelativeDestination(file.category, file.filename),
-          category: file.category,
-          strategy,
-          encrypted: options.encrypt || false,
-          template: options.template || false,
-          permissions: info.permissions,
-          added: now,
-          modified: now,
-          checksum
-        });
-        const categoryInfo = CATEGORIES[file.category];
-        const icon = categoryInfo?.icon || "-";
-        logger.success(`Added ${file.source}`);
-        logger.dim(`  ${icon} Category: ${file.category}`);
-        if (file.isDir) {
-          logger.dim(`  [dir] Directory with ${file.fileCount} files`);
+      const useSymlink = options.symlink || config.files.strategy === "symlink";
+      const shouldBackup = options.backup ?? config.files.backupOnRestore;
+      const hookOptions = {
+        skipHooks: options.noHooks,
+        trustHooks: options.trustHooks
+      };
+      await runPreRestoreHook(tuckDir, hookOptions);
+      let restoredCount = 0;
+      for (const file of files) {
+        const targetPath = expandPath(file.source);
+        if (!await pathExists(file.destination)) {
+          logger.warning(`Source not found in repository: ${file.source}`);
+          continue;
+        }
+        if (options.dryRun) {
+          if (file.existsAtTarget) {
+            logger.file("modify", `${file.source} (would overwrite)`);
+          } else {
+            logger.file("add", `${file.source} (would create)`);
+          }
+          continue;
         }
-        if (file.sensitive) {
-          console.log(chalk7.yellow(`  [!] Warning: This file may contain sensitive data`));
-          console.log(chalk7.dim(`      Make sure your repository is private!`));
+        if (shouldBackup && file.existsAtTarget) {
+          await withSpinner(`Backing up ${file.source}...`, async () => {
+            await createBackup(targetPath);
+          });
         }
+        await withSpinner(`Restoring ${file.source}...`, async () => {
+          if (useSymlink) {
+            await createSymlink(file.destination, targetPath, { overwrite: true });
+          } else {
+            await copyFileOrDir(file.destination, targetPath, { overwrite: true });
+          }
+          await fixSSHPermissions(file.source);
+          await fixGPGPermissions(file.source);
+        });
+        restoredCount++;
       }
+      await runPostRestoreHook(tuckDir, hookOptions);
+      return restoredCount;
     };
-    runInteractiveAdd = async (tuckDir) => {
-      prompts.intro("tuck add");
-      const pathsInput = await prompts.text("Enter file paths to track (space-separated):", {
-        placeholder: "~/.zshrc ~/.gitconfig",
-        validate: (value) => {
-          if (!value.trim()) return "At least one path is required";
-          return void 0;
-        }
+    runInteractiveRestore = async (tuckDir) => {
+      prompts.intro("tuck restore");
+      const files = await prepareFilesToRestore(tuckDir);
+      if (files.length === 0) {
+        prompts.log.warning("No files to restore");
+        prompts.note("Run 'tuck add <path>' to track files first", "Tip");
+        return;
+      }
+      const fileOptions = files.map((file) => {
+        const categoryConfig = CATEGORIES[file.category] || { icon: "\u{1F4C4}" };
+        const status = file.existsAtTarget ? chalk10.yellow("(exists, will backup)") : "";
+        return {
+          value: file.id,
+          label: `${categoryConfig.icon} ${file.source} ${status}`,
+          hint: file.category
+        };
       });
-      const paths = pathsInput.split(/\s+/).filter(Boolean);
-      let filesToAdd;
-      try {
-        filesToAdd = await validateAndPrepareFiles(paths, tuckDir, {});
-      } catch (error) {
-        if (error instanceof Error) {
-          prompts.log.error(error.message);
-        }
-        prompts.cancel();
+      const selectedIds = await prompts.multiselect("Select files to restore:", fileOptions, true);
+      if (selectedIds.length === 0) {
+        prompts.cancel("No files selected");
         return;
       }
-      for (const file of filesToAdd) {
-        prompts.log.step(`${file.source}`);
-        const categoryOptions = Object.entries(CATEGORIES).map(([name, config]) => ({
-          value: name,
-          label: `${config.icon} ${name}`,
-          hint: file.category === name ? "(auto-detected)" : void 0
-        }));
-        categoryOptions.sort((a, b) => {
-          if (a.value === file.category) return -1;
-          if (b.value === file.category) return 1;
-          return 0;
-        });
-        const selectedCategory = await prompts.select("Category:", categoryOptions);
-        file.category = selectedCategory;
-        file.destination = getDestinationPath(tuckDir, file.category, file.filename);
+      const selectedFiles = files.filter((f) => selectedIds.includes(f.id));
+      const existingFiles = selectedFiles.filter((f) => f.existsAtTarget);
+      if (existingFiles.length > 0) {
+        console.log();
+        prompts.log.warning(
+          `${existingFiles.length} file${existingFiles.length > 1 ? "s" : ""} will be backed up:`
+        );
+        existingFiles.forEach((f) => console.log(chalk10.dim(`  ${f.source}`)));
+        console.log();
       }
+      const useSymlink = await prompts.select("Restore method:", [
+        { value: false, label: "Copy files", hint: "Recommended" },
+        { value: true, label: "Create symlinks", hint: "Files stay in tuck repo" }
+      ]);
       const confirm2 = await prompts.confirm(
-        `Add ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}?`,
+        `Restore ${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""}?`,
         true
       );
       if (!confirm2) {
         prompts.cancel("Operation cancelled");
         return;
       }
-      await addFiles(filesToAdd, tuckDir, {});
-      prompts.outro(`Added ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}`);
-      logger.info("Run 'tuck sync' to commit changes");
+      const restoredCount = await restoreFiles(tuckDir, selectedFiles, {
+        symlink: useSymlink,
+        backup: true
+      });
+      console.log();
+      prompts.outro(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
+    };
+    runRestore = async (options) => {
+      const tuckDir = getTuckDir();
+      try {
+        await loadManifest(tuckDir);
+      } catch {
+        throw new NotInitializedError();
+      }
+      if (options.all) {
+        const files = await prepareFilesToRestore(tuckDir, void 0);
+        if (files.length === 0) {
+          logger.warning("No files to restore");
+          return;
+        }
+        const restoredCount = await restoreFiles(tuckDir, files, options);
+        logger.blank();
+        logger.success(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
+      } else {
+        await runInteractiveRestore(tuckDir);
+      }
+    };
+    runRestoreCommand = async (paths, options) => {
+      const tuckDir = getTuckDir();
+      try {
+        await loadManifest(tuckDir);
+      } catch {
+        throw new NotInitializedError();
+      }
+      if (paths.length === 0 && !options.all) {
+        await runInteractiveRestore(tuckDir);
+        return;
+      }
+      const files = await prepareFilesToRestore(tuckDir, options.all ? void 0 : paths);
+      if (files.length === 0) {
+        logger.warning("No files to restore");
+        return;
+      }
+      if (options.dryRun) {
+        logger.heading("Dry run - would restore:");
+      } else {
+        logger.heading("Restoring:");
+      }
+      const restoredCount = await restoreFiles(tuckDir, files, options);
+      logger.blank();
+      if (options.dryRun) {
+        logger.info(`Would restore ${files.length} file${files.length > 1 ? "s" : ""}`);
+      } else {
+        logger.success(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
+      }
+    };
+    restoreCommand = new Command("restore").description("Restore dotfiles to the system").argument("[paths...]", "Paths to restore (or use --all)").option("-a, --all", "Restore all tracked files").option("--symlink", "Create symlinks instead of copies").option("--backup", "Backup existing files before restore").option("--no-backup", "Skip backup of existing files").option("--dry-run", "Show what would be done").option("--no-hooks", "Skip execution of pre/post restore hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (paths, options) => {
+      await runRestoreCommand(paths, options);
+    });
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  runSync: () => runSync,
+  syncCommand: () => syncCommand
+});
+import { Command as Command2 } from "commander";
+import chalk11 from "chalk";
+import { join as join9 } from "path";
+var detectChanges, generateCommitMessage, syncFiles, runInteractiveSync, runSync, runSyncCommand, syncCommand;
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_ui();
+    init_paths();
+    init_manifest();
+    init_git();
+    init_files();
+    init_hooks();
+    init_errors();
+    detectChanges = async (tuckDir) => {
+      const files = await getAllTrackedFiles(tuckDir);
+      const changes = [];
+      for (const [, file] of Object.entries(files)) {
+        const sourcePath = expandPath(file.source);
+        if (!await pathExists(sourcePath)) {
+          changes.push({
+            path: file.source,
+            status: "deleted",
+            source: file.source,
+            destination: file.destination
+          });
+          continue;
+        }
+        try {
+          const sourceChecksum = await getFileChecksum(sourcePath);
+          if (sourceChecksum !== file.checksum) {
+            changes.push({
+              path: file.source,
+              status: "modified",
+              source: file.source,
+              destination: file.destination
+            });
+          }
+        } catch {
+          changes.push({
+            path: file.source,
+            status: "modified",
+            source: file.source,
+            destination: file.destination
+          });
+        }
+      }
+      return changes;
+    };
+    generateCommitMessage = (result) => {
+      const parts = [];
+      if (result.modified.length > 0) {
+        parts.push(`Update: ${result.modified.join(", ")}`);
+      }
+      if (result.deleted.length > 0) {
+        parts.push(`Remove: ${result.deleted.join(", ")}`);
+      }
+      if (parts.length === 0) {
+        return "Sync dotfiles";
+      }
+      const totalCount = result.modified.length + result.deleted.length;
+      if (parts.length === 1 && totalCount <= 3) {
+        return parts[0];
+      }
+      return `Sync: ${totalCount} file${totalCount > 1 ? "s" : ""} changed`;
+    };
+    syncFiles = async (tuckDir, changes, options) => {
+      const result = {
+        modified: [],
+        deleted: []
+      };
+      const hookOptions = {
+        skipHooks: options.noHooks,
+        trustHooks: options.trustHooks
+      };
+      await runPreSyncHook(tuckDir, hookOptions);
+      for (const change of changes) {
+        const sourcePath = expandPath(change.source);
+        const destPath = join9(tuckDir, change.destination);
+        if (change.status === "modified") {
+          await withSpinner(`Syncing ${change.path}...`, async () => {
+            await copyFileOrDir(sourcePath, destPath, { overwrite: true });
+            const newChecksum = await getFileChecksum(destPath);
+            const files = await getAllTrackedFiles(tuckDir);
+            const fileId = Object.entries(files).find(([, f]) => f.source === change.source)?.[0];
+            if (fileId) {
+              await updateFileInManifest(tuckDir, fileId, {
+                checksum: newChecksum,
+                modified: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          });
+          result.modified.push(change.path.split("/").pop() || change.path);
+        } else if (change.status === "deleted") {
+          await withSpinner(`Removing ${change.path}...`, async () => {
+            await deleteFileOrDir(destPath);
+            const files = await getAllTrackedFiles(tuckDir);
+            const fileId = Object.entries(files).find(([, f]) => f.source === change.source)?.[0];
+            if (fileId) {
+              await removeFileFromManifest(tuckDir, fileId);
+            }
+          });
+          result.deleted.push(change.path.split("/").pop() || change.path);
+        }
+      }
+      if (!options.noCommit && (result.modified.length > 0 || result.deleted.length > 0)) {
+        await withSpinner("Staging changes...", async () => {
+          await stageAll(tuckDir);
+        });
+        const message = options.message || generateCommitMessage(result);
+        await withSpinner("Committing...", async () => {
+          result.commitHash = await commit(tuckDir, message);
+        });
+      }
+      await runPostSyncHook(tuckDir, hookOptions);
+      return result;
+    };
+    runInteractiveSync = async (tuckDir, options = {}) => {
+      prompts.intro("tuck sync");
+      const spinner2 = prompts.spinner();
+      spinner2.start("Detecting changes...");
+      const changes = await detectChanges(tuckDir);
+      spinner2.stop("Changes detected");
+      if (changes.length === 0) {
+        const gitStatus = await getStatus(tuckDir);
+        if (gitStatus.hasChanges) {
+          prompts.log.info("No dotfile changes, but repository has uncommitted changes");
+          const commitAnyway = await prompts.confirm("Commit repository changes?");
+          if (commitAnyway) {
+            const message2 = await prompts.text("Commit message:", {
+              defaultValue: "Update dotfiles"
+            });
+            await stageAll(tuckDir);
+            const hash = await commit(tuckDir, message2);
+            prompts.log.success(`Committed: ${hash.slice(0, 7)}`);
+          }
+        } else {
+          prompts.log.success("Everything is up to date");
+        }
+        return;
+      }
+      console.log();
+      console.log(chalk11.bold("Changes detected:"));
+      for (const change of changes) {
+        if (change.status === "modified") {
+          console.log(chalk11.yellow(`  ~ ${change.path}`));
+        } else if (change.status === "deleted") {
+          console.log(chalk11.red(`  - ${change.path}`));
+        }
+      }
+      console.log();
+      const confirm2 = await prompts.confirm("Sync these changes?", true);
+      if (!confirm2) {
+        prompts.cancel("Operation cancelled");
+        return;
+      }
+      const autoMessage = generateCommitMessage({
+        modified: changes.filter((c) => c.status === "modified").map((c) => c.path),
+        deleted: changes.filter((c) => c.status === "deleted").map((c) => c.path)
+      });
+      const message = await prompts.text("Commit message:", {
+        defaultValue: autoMessage
+      });
+      const result = await syncFiles(tuckDir, changes, { message });
+      console.log();
+      if (result.commitHash) {
+        prompts.log.success(`Committed: ${result.commitHash.slice(0, 7)}`);
+        if (options.push !== false && await hasRemote(tuckDir)) {
+          const spinner22 = prompts.spinner();
+          spinner22.start("Pushing to remote...");
+          try {
+            await push(tuckDir);
+            spinner22.stop("Pushed to remote");
+          } catch {
+            spinner22.stop("Push failed (will retry on next sync)");
+          }
+        } else if (options.push === false) {
+          prompts.log.info("Run 'tuck push' when ready to upload");
+        }
+      }
+      prompts.outro("Synced successfully!");
     };
-    addFilesFromPaths = async (paths, options = {}) => {
+    runSync = async (options = {}) => {
       const tuckDir = getTuckDir();
       try {
         await loadManifest(tuckDir);
       } catch {
         throw new NotInitializedError();
       }
-      const filesToAdd = await validateAndPrepareFiles(paths, tuckDir, options);
-      await addFiles(filesToAdd, tuckDir, options);
-      return filesToAdd.length;
+      await runInteractiveSync(tuckDir, options);
     };
-    runAdd = async (paths, options) => {
+    runSyncCommand = async (messageArg, options) => {
       const tuckDir = getTuckDir();
       try {
         await loadManifest(tuckDir);
       } catch {
         throw new NotInitializedError();
       }
-      if (paths.length === 0) {
-        await runInteractiveAdd(tuckDir);
+      if (!messageArg && !options.message && !options.noCommit) {
+        await runInteractiveSync(tuckDir, options);
+        return;
+      }
+      const changes = await detectChanges(tuckDir);
+      if (changes.length === 0) {
+        logger.info("No changes detected");
         return;
       }
-      const filesToAdd = await validateAndPrepareFiles(paths, tuckDir, options);
-      await addFiles(filesToAdd, tuckDir, options);
+      logger.heading("Changes detected:");
+      for (const change of changes) {
+        logger.file(change.status === "modified" ? "modify" : "delete", change.path);
+      }
+      logger.blank();
+      const message = messageArg || options.message;
+      const result = await syncFiles(tuckDir, changes, { ...options, message });
       logger.blank();
-      logger.success(`Added ${filesToAdd.length} ${filesToAdd.length === 1 ? "item" : "items"}`);
-      logger.info("Run 'tuck sync' to commit changes");
+      logger.success(`Synced ${changes.length} file${changes.length > 1 ? "s" : ""}`);
+      if (result.commitHash) {
+        logger.info(`Commit: ${result.commitHash.slice(0, 7)}`);
+        if (options.push !== false && await hasRemote(tuckDir)) {
+          await withSpinner("Pushing to remote...", async () => {
+            await push(tuckDir);
+          });
+          logger.success("Pushed to remote");
+        } else if (options.push === false) {
+          logger.info("Run 'tuck push' when ready to upload");
+        }
+      }
     };
-    addCommand = new Command2("add").description("Track new dotfiles").argument("[paths...]", "Paths to dotfiles to track").option("-c, --category <name>", "Category to organize under").option("-n, --name <name>", "Custom name for the file in manifest").option("--symlink", "Create symlink instead of copy").option("--encrypt", "Encrypt this file (requires GPG setup)").option("--template", "Treat as template with variable substitution").action(async (paths, options) => {
-      await runAdd(paths, options);
+    syncCommand = new Command2("sync").description("Sync changes to repository (commits and pushes)").argument("[message]", "Commit message").option("-m, --message <msg>", "Commit message").option("--no-commit", "Stage changes but don't commit").option("--no-push", "Commit but don't push to remote").option("--no-hooks", "Skip execution of pre/post sync hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (messageArg, options) => {
+      await runSyncCommand(messageArg, options);
     });
   }
 });
 
 // src/index.ts
 import { Command as Command15 } from "commander";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 
 // src/commands/init.ts
 init_ui();
@@ -1839,10 +2262,10 @@ init_config();
 init_manifest();
 init_git();
 init_github();
-import { Command } from "commander";
-import { join as join6, resolve as resolve2, sep } from "path";
+import { Command as Command3 } from "commander";
+import { join as join10, resolve as resolve2, sep as sep2 } from "path";
 import { writeFile as writeFile4 } from "fs/promises";
-import { ensureDir as ensureDir2 } from "fs-extra";
+import { ensureDir as ensureDir5 } from "fs-extra";
 
 // src/lib/detect.ts
 init_paths();
@@ -2239,7 +2662,7 @@ var detectDotfiles = async () => {
 // src/lib/timemachine.ts
 init_paths();
 init_errors();
-import { join as join5, dirname as dirname2 } from "path";
+import { join as join5, dirname as dirname3 } from "path";
 import { readdir as readdir2, readFile as readFile3, writeFile as writeFile3, rm, stat as stat3 } from "fs/promises";
 import { copy, ensureDir, pathExists as pathExists2 } from "fs-extra";
 import { homedir as homedir3 } from "os";
@@ -2273,7 +2696,7 @@ var createSnapshot = async (filePaths, reason, profile) => {
     const backupPath = join5(snapshotPath, "files", backupRelativePath);
     const existed = await pathExists(expandedPath);
     if (existed) {
-      await ensureDir(dirname2(backupPath));
+      await ensureDir(dirname3(backupPath));
       await copy(expandedPath, backupPath, { overwrite: true, preserveTimestamps: true });
     }
     files.push({
@@ -2382,7 +2805,7 @@ var restoreSnapshot = async (snapshotId) => {
       continue;
     }
     if (await pathExists2(file.backupPath)) {
-      await ensureDir(dirname2(file.originalPath));
+      await ensureDir(dirname3(file.originalPath));
       await copy(file.backupPath, file.originalPath, { overwrite: true, preserveTimestamps: true });
       restoredFiles.push(file.originalPath);
     }
@@ -2410,7 +2833,7 @@ var restoreFileFromSnapshot = async (snapshotId, filePath) => {
   if (!await pathExists2(file.backupPath)) {
     throw new BackupError(`Backup file is missing: ${file.backupPath}`);
   }
-  await ensureDir(dirname2(file.originalPath));
+  await ensureDir(dirname3(file.originalPath));
   await copy(file.backupPath, file.originalPath, { overwrite: true, preserveTimestamps: true });
   return true;
 };
@@ -2468,33 +2891,189 @@ var formatSnapshotDate = (snapshotId) => {
 init_errors();
 init_constants();
 init_config_schema();
-import { copy as copy2 } from "fs-extra";
+import { copy as copy4 } from "fs-extra";
 import { tmpdir } from "os";
-import { readFile as readFile4, rm as rm2 } from "fs/promises";
-var GITIGNORE_TEMPLATE = `# OS generated files
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-
-# Backup files
-*.bak
-*.backup
-*~
-
-# Secret files (add patterns for files you want to exclude)
-# *.secret
-# .env.local
-`;
-var README_TEMPLATE = (machine) => `# Dotfiles
-
-Managed with [tuck](https://github.com/Pranav-Karra-3301/tuck) - Modern Dotfiles Manager
-
-${machine ? `## Machine: ${machine}
-` : ""}
+import { readFile as readFile5, rm as rm3 } from "fs/promises";
+
+// src/lib/fileTracking.ts
+init_paths();
+init_manifest();
+init_files();
+init_config();
+init_constants();
+import chalk8 from "chalk";
+import ora3 from "ora";
+import { ensureDir as ensureDir3 } from "fs-extra";
+import { dirname as dirname5 } from "path";
+var SENSITIVE_FILE_PATTERNS = [
+  /^\.netrc$/,
+  /^\.aws\/credentials$/,
+  /^\.docker\/config\.json$/,
+  /^\.npmrc$/,
+  /^\.pypirc$/,
+  /^\.kube\/config$/,
+  /^\.ssh\/config$/,
+  /^\.gnupg\//,
+  /credentials/i,
+  /secrets?/i,
+  /tokens?\.json$/i,
+  /\.env$/,
+  /\.env\./
+];
+var isSensitiveFile = (path) => {
+  const pathToTest = path.startsWith("~/") ? path.slice(2) : path;
+  for (const pattern of SENSITIVE_FILE_PATTERNS) {
+    if (pattern.test(pathToTest)) {
+      return true;
+    }
+  }
+  return false;
+};
+var trackFilesWithProgress = async (files, tuckDir, options = {}) => {
+  const {
+    showCategory = true,
+    strategy: customStrategy,
+    // TODO: Encryption and templating are planned for a future version
+    // encrypt = false,
+    // template = false,
+    actionVerb = "Tracking",
+    onProgress
+  } = options;
+  let { delayBetween } = options;
+  if (delayBetween === void 0) {
+    delayBetween = files.length >= 50 ? 10 : 30;
+  }
+  const config = await loadConfig(tuckDir);
+  const strategy = customStrategy || config.files.strategy || "copy";
+  const total = files.length;
+  const errors = [];
+  const sensitiveFiles = [];
+  let succeeded = 0;
+  console.log();
+  console.log(chalk8.bold.cyan(`${actionVerb} ${total} ${total === 1 ? "file" : "files"}...`));
+  console.log(chalk8.dim("\u2500".repeat(50)));
+  console.log();
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const expandedPath = expandPath(file.path);
+    const indexStr = chalk8.dim(`[${i + 1}/${total}]`);
+    const category = file.category || detectCategory(expandedPath);
+    const filename = sanitizeFilename(expandedPath);
+    const categoryInfo = CATEGORIES[category];
+    const icon = categoryInfo?.icon || "\u25CB";
+    const spinner2 = ora3({
+      text: `${indexStr} ${actionVerb} ${chalk8.cyan(collapsePath(file.path))}`,
+      color: "cyan",
+      spinner: "dots",
+      indent: 2
+    }).start();
+    try {
+      const destination = getDestinationPath(tuckDir, category, filename);
+      await ensureDir3(dirname5(destination));
+      if (strategy === "symlink") {
+        await createSymlink(expandedPath, destination, { overwrite: true });
+      } else {
+        await copyFileOrDir(expandedPath, destination, { overwrite: true });
+      }
+      const checksum = await getFileChecksum(destination);
+      const info = await getFileInfo(expandedPath);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const id = generateFileId(file.path);
+      await addFileToManifest(tuckDir, id, {
+        source: collapsePath(file.path),
+        destination: getRelativeDestination(category, filename),
+        category,
+        strategy,
+        // TODO: Encryption and templating are planned for a future version
+        encrypted: false,
+        template: false,
+        permissions: info.permissions,
+        added: now,
+        modified: now,
+        checksum
+      });
+      spinner2.stop();
+      const categoryStr = showCategory ? chalk8.dim(` ${icon} ${category}`) : "";
+      console.log(`  ${chalk8.green("\u2713")} ${indexStr} ${collapsePath(file.path)}${categoryStr}`);
+      if (isSensitiveFile(collapsePath(file.path))) {
+        sensitiveFiles.push(file.path);
+      }
+      succeeded++;
+      if (onProgress) {
+        onProgress(i + 1, total);
+      }
+      if (i < files.length - 1 && delayBetween > 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, delayBetween));
+      }
+    } catch (error) {
+      spinner2.stop();
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      errors.push({ path: file.path, error: errorObj });
+      console.log(`  ${chalk8.red("\u2717")} ${indexStr} ${collapsePath(file.path)} ${chalk8.red("- failed")}`);
+    }
+  }
+  console.log();
+  if (succeeded > 0) {
+    console.log(chalk8.green("\u2713"), chalk8.bold(`Tracked ${succeeded} ${succeeded === 1 ? "file" : "files"} successfully`));
+  }
+  if (errors.length > 0) {
+    console.log();
+    console.log(chalk8.red("\u2717"), chalk8.bold(`Failed to track ${errors.length} ${errors.length === 1 ? "file" : "files"}:`));
+    for (const { path, error } of errors) {
+      console.log(chalk8.dim(`   \u2022 ${collapsePath(path)}: ${error.message}`));
+    }
+  }
+  if (sensitiveFiles.length > 0) {
+    console.log();
+    console.log(chalk8.yellow("\u26A0"), chalk8.yellow("Warning: Some files may contain sensitive data:"));
+    for (const path of sensitiveFiles) {
+      console.log(chalk8.dim(`   \u2022 ${collapsePath(path)}`));
+    }
+    console.log(chalk8.dim("  Make sure your repository is private!"));
+  }
+  return {
+    succeeded,
+    failed: errors.length,
+    errors,
+    sensitiveFiles
+  };
+};
+
+// src/commands/init.ts
+var GITIGNORE_TEMPLATE = `# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Backup files
+*.bak
+*.backup
+*~
+
+# Secret files (add patterns for files you want to exclude)
+# *.secret
+# .env.local
+`;
+var trackFilesWithProgressInit = async (selectedPaths, tuckDir) => {
+  const filesToTrack = selectedPaths.map((path) => ({
+    path
+  }));
+  const result = await trackFilesWithProgress(filesToTrack, tuckDir, {
+    showCategory: true,
+    actionVerb: "Tracking"
+  });
+  return result.succeeded;
+};
+var README_TEMPLATE = (machine) => `# Dotfiles
+
+Managed with [tuck](https://github.com/Pranav-Karra-3301/tuck) - Modern Dotfiles Manager
+
+${machine ? `## Machine: ${machine}
+` : ""}
 
 ## Quick Start
 
@@ -2534,18 +3113,18 @@ tuck restore --all
 \`\`\`
 `;
 var createDirectoryStructure = async (tuckDir) => {
-  await ensureDir2(tuckDir);
-  await ensureDir2(getFilesDir(tuckDir));
+  await ensureDir5(tuckDir);
+  await ensureDir5(getFilesDir(tuckDir));
   for (const category of Object.keys(CATEGORIES)) {
-    await ensureDir2(getCategoryDir(tuckDir, category));
+    await ensureDir5(getCategoryDir(tuckDir, category));
   }
 };
 var createDefaultFiles = async (tuckDir, machine) => {
-  const gitignorePath = join6(tuckDir, ".gitignore");
+  const gitignorePath = join10(tuckDir, ".gitignore");
   if (!await pathExists(gitignorePath)) {
     await writeFile4(gitignorePath, GITIGNORE_TEMPLATE, "utf-8");
   }
-  const readmePath = join6(tuckDir, "README.md");
+  const readmePath = join10(tuckDir, "README.md");
   if (!await pathExists(readmePath)) {
     await writeFile4(readmePath, README_TEMPLATE(machine), "utf-8");
   }
@@ -2665,10 +3244,10 @@ tuck apply ${user.login}`,
   return { remoteUrl, pushed: false };
 };
 var analyzeRepository = async (repoDir) => {
-  const manifestPath = join6(repoDir, ".tuckmanifest.json");
+  const manifestPath = join10(repoDir, ".tuckmanifest.json");
   if (await pathExists(manifestPath)) {
     try {
-      const content = await readFile4(manifestPath, "utf-8");
+      const content = await readFile5(manifestPath, "utf-8");
       const manifest = JSON.parse(content);
       if (manifest.files && Object.keys(manifest.files).length > 0) {
         return { type: "valid-tuck", manifest };
@@ -2678,7 +3257,7 @@ var analyzeRepository = async (repoDir) => {
       return { type: "messed-up", reason: "Manifest file is corrupted or invalid" };
     }
   }
-  const filesDir = join6(repoDir, "files");
+  const filesDir = join10(repoDir, "files");
   const hasFilesDir = await pathExists(filesDir);
   const commonPatterns = [
     ".zshrc",
@@ -2699,7 +3278,7 @@ var analyzeRepository = async (repoDir) => {
     try {
       const categories = await readdir5(filesDir);
       for (const category of categories) {
-        const categoryPath = join6(filesDir, category);
+        const categoryPath = join10(filesDir, category);
         const categoryStats = await import("fs/promises").then((fs) => fs.stat(categoryPath).catch(() => null));
         if (categoryStats?.isDirectory()) {
           const files = await readdir5(categoryPath);
@@ -2740,9 +3319,9 @@ var analyzeRepository = async (repoDir) => {
   return { type: "messed-up", reason: "Repository does not contain recognizable dotfiles" };
 };
 var validateDestinationPath = (tuckDir, destination) => {
-  const fullPath = resolve2(join6(tuckDir, destination));
+  const fullPath = resolve2(join10(tuckDir, destination));
   const normalizedTuckDir = resolve2(tuckDir);
-  return fullPath.startsWith(normalizedTuckDir + sep) || fullPath === normalizedTuckDir;
+  return fullPath.startsWith(normalizedTuckDir + sep2) || fullPath === normalizedTuckDir;
 };
 var importExistingRepo = async (tuckDir, repoName, analysis, repoDir) => {
   const { getPreferredRemoteProtocol: getPreferredRemoteProtocol2 } = await Promise.resolve().then(() => (init_github(), github_exports));
@@ -2752,7 +3331,7 @@ var importExistingRepo = async (tuckDir, repoName, analysis, repoDir) => {
     prompts.log.step("Importing tuck repository...");
     const spinner2 = prompts.spinner();
     spinner2.start("Copying repository...");
-    await copy2(repoDir, tuckDir, { overwrite: true });
+    await copy4(repoDir, tuckDir, { overwrite: true });
     spinner2.stop("Repository copied");
     const fileCount = Object.keys(analysis.manifest.files).length;
     let appliedCount = 0;
@@ -2791,12 +3370,12 @@ var importExistingRepo = async (tuckDir, repoName, analysis, repoDir) => {
       const applySpinner = prompts.spinner();
       applySpinner.start("Applying dotfiles...");
       for (const file of validFiles) {
-        const repoFilePath = join6(tuckDir, file.destination);
+        const repoFilePath = join10(tuckDir, file.destination);
         const destPath = expandPath(file.source);
         if (await pathExists(repoFilePath)) {
-          const destDir = join6(destPath, "..");
-          await ensureDir2(destDir);
-          await copy2(repoFilePath, destPath, { overwrite: true });
+          const destDir = join10(destPath, "..");
+          await ensureDir5(destDir);
+          await copy4(repoFilePath, destPath, { overwrite: true });
           appliedCount++;
         }
       }
@@ -2809,7 +3388,7 @@ var importExistingRepo = async (tuckDir, repoName, analysis, repoDir) => {
     prompts.log.info("Importing repository and setting up tuck...");
     const copySpinner = prompts.spinner();
     copySpinner.start("Copying repository contents...");
-    await copy2(repoDir, tuckDir, { overwrite: true });
+    await copy4(repoDir, tuckDir, { overwrite: true });
     copySpinner.stop("Repository contents copied");
     await setDefaultBranch(tuckDir, "main");
     const hostname2 = (await import("os")).hostname();
@@ -2864,7 +3443,7 @@ var importExistingRepo = async (tuckDir, repoName, analysis, repoDir) => {
         const entries = await readdir4(dir);
         for (const entry of entries) {
           if (entry === ".git" || entry === ".tuckmanifest.json" || entry === ".tuckrc.json") continue;
-          const fullPath = join6(dir, entry);
+          const fullPath = join10(dir, entry);
           const stats = await stat7(fullPath).catch(() => null);
           if (stats?.isDirectory()) {
             count += await countFiles(fullPath);
@@ -2971,7 +3550,7 @@ var runInteractiveInit = async () => {
           true
         );
         if (importRepo) {
-          const tempDir = join6(tmpdir(), `tuck-import-${Date.now()}`);
+          const tempDir = join10(tmpdir(), `tuck-import-${Date.now()}`);
           const cloneSpinner = prompts.spinner();
           cloneSpinner.start("Cloning repository...");
           let phase = "cloning";
@@ -3032,7 +3611,7 @@ var runInteractiveInit = async () => {
           } finally {
             if (await pathExists(tempDir)) {
               try {
-                await rm2(tempDir, { recursive: true, force: true });
+                await rm3(tempDir, { recursive: true, force: true });
               } catch (cleanupError) {
                 prompts.log.warning(
                   `Failed to clean up temporary directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`
@@ -3067,33 +3646,66 @@ var runInteractiveInit = async () => {
     prompts.log.success("Repository cloned successfully!");
     const shouldRestore = await prompts.confirm("Would you like to restore dotfiles now?", true);
     if (shouldRestore) {
-      prompts.log.info("Run `tuck restore --all` to restore all dotfiles");
+      console.log();
+      const { runRestore: runRestore2 } = await Promise.resolve().then(() => (init_restore(), restore_exports));
+      await runRestore2({ all: true });
     }
   } else {
-    const existingDotfiles = [];
-    for (const df of COMMON_DOTFILES) {
-      const fullPath = expandPath(df.path);
-      if (await pathExists(fullPath)) {
-        existingDotfiles.push({
-          path: df.path,
-          label: `${df.path} (${df.category})`
-        });
-      }
-    }
     await initFromScratch(tuckDir, {});
-    if (existingDotfiles.length > 0) {
-      const selectedFiles = await prompts.multiselect(
-        "Would you like to track some common dotfiles?",
-        existingDotfiles.map((f) => ({
+    const scanSpinner = prompts.spinner();
+    scanSpinner.start("Scanning for dotfiles...");
+    const detectedFiles = await detectDotfiles();
+    const nonSensitiveFiles = detectedFiles.filter((f) => !f.sensitive);
+    scanSpinner.stop(`Found ${nonSensitiveFiles.length} dotfiles on your system`);
+    if (nonSensitiveFiles.length > 0) {
+      const grouped = {};
+      for (const file of nonSensitiveFiles) {
+        if (!grouped[file.category]) grouped[file.category] = [];
+        grouped[file.category].push(file);
+      }
+      console.log();
+      const categoryOrder = ["shell", "git", "editors", "terminal", "ssh", "misc"];
+      const sortedCategories = Object.keys(grouped).sort((a, b) => {
+        const aIdx = categoryOrder.indexOf(a);
+        const bIdx = categoryOrder.indexOf(b);
+        if (aIdx === -1 && bIdx === -1) return a.localeCompare(b);
+        if (aIdx === -1) return 1;
+        if (bIdx === -1) return -1;
+        return aIdx - bIdx;
+      });
+      for (const category of sortedCategories) {
+        const files = grouped[category];
+        const config = DETECTION_CATEGORIES[category] || { icon: "-", name: category };
+        console.log(`  ${config.icon} ${config.name}: ${files.length} files`);
+      }
+      console.log();
+      const trackNow = await prompts.confirm("Would you like to track some of these now?", true);
+      if (trackNow) {
+        const options = nonSensitiveFiles.map((f) => ({
           value: f.path,
-          label: f.label
-        }))
-      );
-      if (selectedFiles.length > 0) {
-        prompts.log.step(
-          `Run the following to track these files:
-  tuck add ${selectedFiles.join(" ")}`
+          label: `${collapsePath(f.path)}`,
+          hint: f.category
+        }));
+        const selectedFiles = await prompts.multiselect(
+          "Select files to track:",
+          options
         );
+        if (selectedFiles.length > 0) {
+          const trackedCount = await trackFilesWithProgressInit(selectedFiles, tuckDir);
+          if (trackedCount > 0) {
+            console.log();
+            const shouldSync = await prompts.confirm("Would you like to sync these changes now?", true);
+            if (shouldSync) {
+              console.log();
+              const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+              await runSync2({});
+            }
+          } else {
+            prompts.outro("No files were tracked");
+          }
+        }
+      } else {
+        prompts.log.info("Run 'tuck scan' later to interactively add files");
       }
     }
     const wantsRemote = await prompts.confirm("Would you like to set up a remote repository?");
@@ -3139,7 +3751,7 @@ var runInit = async (options) => {
     `Push remote:  tuck push`
   ]);
 };
-var initCommand = new Command("init").description("Initialize tuck repository").option("-d, --dir <path>", "Directory for tuck repository", "~/.tuck").option("-r, --remote <url>", "Git remote URL to set up").option("--bare", "Initialize without any default files").option("--from <url>", "Clone from existing tuck repository").action(async (options) => {
+var initCommand = new Command3("init").description("Initialize tuck repository").option("-d, --dir <path>", "Directory for tuck repository", "~/.tuck").option("-r, --remote <url>", "Git remote URL to set up").option("--bare", "Initialize without any default files").option("--from <url>", "Clone from existing tuck repository").action(async (options) => {
   if (!options.remote && !options.bare && !options.from && options.dir === "~/.tuck") {
     await runInteractiveInit();
   } else {
@@ -3147,8 +3759,188 @@ var initCommand = new Command("init").description("Initialize tuck repository").
   }
 });
 
-// src/commands/index.ts
-init_add();
+// src/commands/add.ts
+init_ui();
+init_paths();
+init_manifest();
+import { Command as Command4 } from "commander";
+import { basename as basename3 } from "path";
+init_errors();
+init_constants();
+init_files();
+var PRIVATE_KEY_PATTERNS = [
+  /^id_rsa$/,
+  /^id_dsa$/,
+  /^id_ecdsa$/,
+  /^id_ed25519$/,
+  /^id_.*$/,
+  // Any id_ file without .pub
+  /\.pem$/,
+  /\.key$/,
+  /^.*_key$/
+  // aws_key, github_key, etc.
+];
+var SENSITIVE_FILE_PATTERNS2 = [
+  /^\.netrc$/,
+  /^\.aws\/credentials$/,
+  /^\.docker\/config\.json$/,
+  /^\.npmrc$/,
+  // May contain tokens
+  /^\.pypirc$/,
+  /^\.kube\/config$/,
+  /^\.ssh\/config$/,
+  /^\.gnupg\//,
+  /credentials/i,
+  /secrets?/i,
+  /tokens?\.json$/i,
+  /\.env$/,
+  /\.env\./
+];
+var isPrivateKey = (path) => {
+  const name = basename3(path);
+  if (path.includes(".ssh/") && !name.endsWith(".pub")) {
+    for (const pattern of PRIVATE_KEY_PATTERNS) {
+      if (pattern.test(name)) {
+        return true;
+      }
+    }
+  }
+  if (name.endsWith(".pem") || name.endsWith(".key")) {
+    return true;
+  }
+  return false;
+};
+var isSensitiveFile2 = (path) => {
+  const pathToTest = path.startsWith("~/") ? path.slice(2) : path;
+  for (const pattern of SENSITIVE_FILE_PATTERNS2) {
+    if (pattern.test(pathToTest)) {
+      return true;
+    }
+  }
+  return false;
+};
+var validateAndPrepareFiles = async (paths, tuckDir, options) => {
+  const filesToAdd = [];
+  for (const path of paths) {
+    const expandedPath = expandPath(path);
+    const collapsedPath = collapsePath(expandedPath);
+    if (isPrivateKey(collapsedPath)) {
+      throw new Error(
+        `Cannot track private key: ${path}
+Private keys should NEVER be committed to a repository.
+If you need to backup SSH keys, use a secure password manager.`
+      );
+    }
+    if (!await pathExists(expandedPath)) {
+      throw new FileNotFoundError(path);
+    }
+    if (await isFileTracked(tuckDir, collapsedPath)) {
+      throw new FileAlreadyTrackedError(path);
+    }
+    const isDir = await isDirectory(expandedPath);
+    const fileCount = isDir ? await getDirectoryFileCount(expandedPath) : 1;
+    const category = options.category || detectCategory(expandedPath);
+    const filename = options.name || sanitizeFilename(expandedPath);
+    const destination = getDestinationPath(tuckDir, category, filename);
+    const sensitive = isSensitiveFile2(collapsedPath);
+    filesToAdd.push({
+      source: collapsedPath,
+      destination,
+      category,
+      filename,
+      isDir,
+      fileCount,
+      sensitive
+    });
+  }
+  return filesToAdd;
+};
+var addFiles = async (filesToAdd, tuckDir, options) => {
+  const filesToTrack = filesToAdd.map((f) => ({
+    path: f.source,
+    category: f.category
+  }));
+  await trackFilesWithProgress(filesToTrack, tuckDir, {
+    showCategory: true,
+    strategy: options.symlink ? "symlink" : void 0,
+    actionVerb: "Tracking"
+  });
+};
+var runInteractiveAdd = async (tuckDir) => {
+  prompts.intro("tuck add");
+  const pathsInput = await prompts.text("Enter file paths to track (space-separated):", {
+    placeholder: "~/.zshrc ~/.gitconfig",
+    validate: (value) => {
+      if (!value.trim()) return "At least one path is required";
+      return void 0;
+    }
+  });
+  const paths = pathsInput.split(/\s+/).filter(Boolean);
+  let filesToAdd;
+  try {
+    filesToAdd = await validateAndPrepareFiles(paths, tuckDir, {});
+  } catch (error) {
+    if (error instanceof Error) {
+      prompts.log.error(error.message);
+    }
+    prompts.cancel();
+    return;
+  }
+  for (const file of filesToAdd) {
+    prompts.log.step(`${file.source}`);
+    const categoryOptions = Object.entries(CATEGORIES).map(([name, config]) => ({
+      value: name,
+      label: `${config.icon} ${name}`,
+      hint: file.category === name ? "(auto-detected)" : void 0
+    }));
+    categoryOptions.sort((a, b) => {
+      if (a.value === file.category) return -1;
+      if (b.value === file.category) return 1;
+      return 0;
+    });
+    const selectedCategory = await prompts.select("Category:", categoryOptions);
+    file.category = selectedCategory;
+    file.destination = getDestinationPath(tuckDir, file.category, file.filename);
+  }
+  const confirm2 = await prompts.confirm(
+    `Add ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}?`,
+    true
+  );
+  if (!confirm2) {
+    prompts.cancel("Operation cancelled");
+    return;
+  }
+  await addFiles(filesToAdd, tuckDir, {});
+  prompts.outro(`Added ${filesToAdd.length} ${filesToAdd.length === 1 ? "file" : "files"}`);
+  logger.info("Run 'tuck sync' to commit changes");
+};
+var runAdd = async (paths, options) => {
+  const tuckDir = getTuckDir();
+  try {
+    await loadManifest(tuckDir);
+  } catch {
+    throw new NotInitializedError();
+  }
+  if (paths.length === 0) {
+    await runInteractiveAdd(tuckDir);
+    return;
+  }
+  const filesToAdd = await validateAndPrepareFiles(paths, tuckDir, options);
+  await addFiles(filesToAdd, tuckDir, options);
+  console.log();
+  const shouldSync = await prompts.confirm("Would you like to sync these changes now?", true);
+  if (shouldSync) {
+    console.log();
+    const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    await runSync2({});
+  } else {
+    console.log();
+    logger.info("Run 'tuck sync' when you're ready to commit changes");
+  }
+};
+var addCommand = new Command4("add").description("Track new dotfiles").argument("[paths...]", "Paths to dotfiles to track").option("-c, --category <name>", "Category to organize under").option("-n, --name <name>", "Custom name for the file in manifest").option("--symlink", "Create symlink instead of copy").action(async (paths, options) => {
+  await runAdd(paths, options);
+});
 
 // src/commands/remove.ts
 init_ui();
@@ -3156,8 +3948,8 @@ init_paths();
 init_manifest();
 init_files();
 init_errors();
-import { Command as Command3 } from "commander";
-import { join as join8 } from "path";
+import { Command as Command5 } from "commander";
+import { join as join11 } from "path";
 var validateAndPrepareFiles2 = async (paths, tuckDir) => {
   const filesToRemove = [];
   for (const path of paths) {
@@ -3170,7 +3962,7 @@ var validateAndPrepareFiles2 = async (paths, tuckDir) => {
     filesToRemove.push({
       id: tracked.id,
       source: tracked.file.source,
-      destination: join8(tuckDir, tracked.file.destination)
+      destination: join11(tuckDir, tracked.file.destination)
     });
   }
   return filesToRemove;
@@ -3227,7 +4019,7 @@ var runInteractiveRemove = async (tuckDir) => {
     return {
       id,
       source: file.source,
-      destination: join8(tuckDir, file.destination)
+      destination: join11(tuckDir, file.destination)
     };
   });
   await removeFiles(filesToRemove, tuckDir, { delete: shouldDelete });
@@ -3251,316 +4043,12 @@ var runRemove = async (paths, options) => {
   logger.success(`Removed ${filesToRemove.length} ${filesToRemove.length === 1 ? "item" : "items"} from tracking`);
   logger.info("Run 'tuck sync' to commit changes");
 };
-var removeCommand = new Command3("remove").description("Stop tracking dotfiles").argument("[paths...]", "Paths to dotfiles to untrack").option("--delete", "Also delete from tuck repository").option("--keep-original", "Don't restore symlinks to regular files").action(async (paths, options) => {
+var removeCommand = new Command5("remove").description("Stop tracking dotfiles").argument("[paths...]", "Paths to dotfiles to untrack").option("--delete", "Also delete from tuck repository").option("--keep-original", "Don't restore symlinks to regular files").action(async (paths, options) => {
   await runRemove(paths, options);
 });
 
-// src/commands/sync.ts
-init_ui();
-init_paths();
-init_manifest();
-init_git();
-init_files();
-import { Command as Command4 } from "commander";
-import chalk9 from "chalk";
-import { join as join9 } from "path";
-
-// src/lib/hooks.ts
-init_config();
-init_logger();
-init_prompts();
-import { exec } from "child_process";
-import { promisify as promisify2 } from "util";
-import chalk8 from "chalk";
-var execAsync = promisify2(exec);
-var runHook = async (hookType, tuckDir, options) => {
-  if (options?.skipHooks) {
-    return { success: true, skipped: true };
-  }
-  const config = await loadConfig(tuckDir);
-  const command = config.hooks[hookType];
-  if (!command) {
-    return { success: true };
-  }
-  if (!options?.trustHooks) {
-    console.log();
-    console.log(chalk8.yellow.bold("WARNING: Hook Execution"));
-    console.log(chalk8.dim("\u2500".repeat(50)));
-    console.log(chalk8.white(`Hook type: ${chalk8.cyan(hookType)}`));
-    console.log(chalk8.white("Command:"));
-    console.log(chalk8.red(`  ${command}`));
-    console.log(chalk8.dim("\u2500".repeat(50)));
-    console.log(
-      chalk8.yellow(
-        "SECURITY: Hooks can execute arbitrary commands on your system."
-      )
-    );
-    console.log(
-      chalk8.yellow(
-        "Only proceed if you trust the source of this configuration."
-      )
-    );
-    console.log();
-    const confirmed = await prompts.confirm(
-      "Execute this hook?",
-      false
-      // Default to NO for safety
-    );
-    if (!confirmed) {
-      logger.warning(`Hook ${hookType} skipped by user`);
-      return { success: true, skipped: true };
-    }
-  }
-  if (!options?.silent) {
-    logger.dim(`Running ${hookType} hook...`);
-  }
-  try {
-    const { stdout, stderr } = await execAsync(command, {
-      cwd: tuckDir,
-      timeout: 3e4,
-      // 30 second timeout
-      env: {
-        ...process.env,
-        TUCK_DIR: tuckDir,
-        TUCK_HOOK: hookType
-      }
-    });
-    if (stdout && !options?.silent) {
-      logger.dim(stdout.trim());
-    }
-    if (stderr && !options?.silent) {
-      logger.warning(stderr.trim());
-    }
-    return { success: true, output: stdout };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    if (!options?.silent) {
-      logger.error(`Hook ${hookType} failed: ${errorMessage}`);
-    }
-    return { success: false, error: errorMessage };
-  }
-};
-var runPreSyncHook = async (tuckDir, options) => {
-  return runHook("preSync", tuckDir, options);
-};
-var runPostSyncHook = async (tuckDir, options) => {
-  return runHook("postSync", tuckDir, options);
-};
-var runPreRestoreHook = async (tuckDir, options) => {
-  return runHook("preRestore", tuckDir, options);
-};
-var runPostRestoreHook = async (tuckDir, options) => {
-  return runHook("postRestore", tuckDir, options);
-};
-
-// src/commands/sync.ts
-init_errors();
-var detectChanges = async (tuckDir) => {
-  const files = await getAllTrackedFiles(tuckDir);
-  const changes = [];
-  for (const [, file] of Object.entries(files)) {
-    const sourcePath = expandPath(file.source);
-    if (!await pathExists(sourcePath)) {
-      changes.push({
-        path: file.source,
-        status: "deleted",
-        source: file.source,
-        destination: file.destination
-      });
-      continue;
-    }
-    try {
-      const sourceChecksum = await getFileChecksum(sourcePath);
-      if (sourceChecksum !== file.checksum) {
-        changes.push({
-          path: file.source,
-          status: "modified",
-          source: file.source,
-          destination: file.destination
-        });
-      }
-    } catch {
-      changes.push({
-        path: file.source,
-        status: "modified",
-        source: file.source,
-        destination: file.destination
-      });
-    }
-  }
-  return changes;
-};
-var generateCommitMessage = (result) => {
-  const parts = [];
-  if (result.added.length > 0) {
-    parts.push(`Add: ${result.added.join(", ")}`);
-  }
-  if (result.modified.length > 0) {
-    parts.push(`Update: ${result.modified.join(", ")}`);
-  }
-  if (result.deleted.length > 0) {
-    parts.push(`Remove: ${result.deleted.join(", ")}`);
-  }
-  if (parts.length === 0) {
-    return "Sync dotfiles";
-  }
-  const totalCount = result.added.length + result.modified.length + result.deleted.length;
-  if (parts.length === 1 && totalCount <= 3) {
-    return parts[0];
-  }
-  return `Sync: ${totalCount} file${totalCount > 1 ? "s" : ""} changed`;
-};
-var syncFiles = async (tuckDir, changes, options) => {
-  const result = {
-    modified: [],
-    added: [],
-    deleted: []
-  };
-  const hookOptions = {
-    skipHooks: options.noHooks,
-    trustHooks: options.trustHooks
-  };
-  await runPreSyncHook(tuckDir, hookOptions);
-  for (const change of changes) {
-    const sourcePath = expandPath(change.source);
-    const destPath = join9(tuckDir, change.destination);
-    if (change.status === "modified") {
-      await withSpinner(`Syncing ${change.path}...`, async () => {
-        await copyFileOrDir(sourcePath, destPath, { overwrite: true });
-        const newChecksum = await getFileChecksum(destPath);
-        const files = await getAllTrackedFiles(tuckDir);
-        const fileId = Object.entries(files).find(([, f]) => f.source === change.source)?.[0];
-        if (fileId) {
-          await updateFileInManifest(tuckDir, fileId, {
-            checksum: newChecksum,
-            modified: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      });
-      result.modified.push(change.path.split("/").pop() || change.path);
-    } else if (change.status === "deleted") {
-      logger.warning(`Source file deleted: ${change.path}`);
-      result.deleted.push(change.path.split("/").pop() || change.path);
-    }
-  }
-  if (!options.noCommit && (result.modified.length > 0 || result.deleted.length > 0)) {
-    await withSpinner("Staging changes...", async () => {
-      await stageAll(tuckDir);
-    });
-    const message = options.message || generateCommitMessage(result);
-    await withSpinner("Committing...", async () => {
-      result.commitHash = await commit(tuckDir, message);
-    });
-  }
-  await runPostSyncHook(tuckDir, hookOptions);
-  return result;
-};
-var runInteractiveSync = async (tuckDir, options = {}) => {
-  prompts.intro("tuck sync");
-  const spinner2 = prompts.spinner();
-  spinner2.start("Detecting changes...");
-  const changes = await detectChanges(tuckDir);
-  spinner2.stop("Changes detected");
-  if (changes.length === 0) {
-    const gitStatus = await getStatus(tuckDir);
-    if (gitStatus.hasChanges) {
-      prompts.log.info("No dotfile changes, but repository has uncommitted changes");
-      const commitAnyway = await prompts.confirm("Commit repository changes?");
-      if (commitAnyway) {
-        const message2 = await prompts.text("Commit message:", {
-          defaultValue: "Update dotfiles"
-        });
-        await stageAll(tuckDir);
-        const hash = await commit(tuckDir, message2);
-        prompts.log.success(`Committed: ${hash.slice(0, 7)}`);
-      }
-    } else {
-      prompts.log.success("Everything is up to date");
-    }
-    return;
-  }
-  console.log();
-  console.log(chalk9.bold("Changes detected:"));
-  for (const change of changes) {
-    if (change.status === "modified") {
-      console.log(chalk9.yellow(`  ~ ${change.path}`));
-    } else if (change.status === "deleted") {
-      console.log(chalk9.red(`  - ${change.path}`));
-    }
-  }
-  console.log();
-  const confirm2 = await prompts.confirm("Sync these changes?", true);
-  if (!confirm2) {
-    prompts.cancel("Operation cancelled");
-    return;
-  }
-  const autoMessage = generateCommitMessage({
-    modified: changes.filter((c) => c.status === "modified").map((c) => c.path),
-    added: [],
-    deleted: changes.filter((c) => c.status === "deleted").map((c) => c.path)
-  });
-  const message = await prompts.text("Commit message:", {
-    defaultValue: autoMessage
-  });
-  const result = await syncFiles(tuckDir, changes, { message });
-  console.log();
-  if (result.commitHash) {
-    prompts.log.success(`Committed: ${result.commitHash.slice(0, 7)}`);
-    if (options.push !== false && await hasRemote(tuckDir)) {
-      const spinner22 = prompts.spinner();
-      spinner22.start("Pushing to remote...");
-      try {
-        await push(tuckDir);
-        spinner22.stop("Pushed to remote");
-      } catch {
-        spinner22.stop("Push failed (will retry on next sync)");
-      }
-    } else if (options.push === false) {
-      prompts.log.info("Run 'tuck push' when ready to upload");
-    }
-  }
-  prompts.outro("Synced successfully!");
-};
-var runSync = async (messageArg, options) => {
-  const tuckDir = getTuckDir();
-  try {
-    await loadManifest(tuckDir);
-  } catch {
-    throw new NotInitializedError();
-  }
-  if (!messageArg && !options.message && !options.all && !options.noCommit && !options.amend) {
-    await runInteractiveSync(tuckDir, options);
-    return;
-  }
-  const changes = await detectChanges(tuckDir);
-  if (changes.length === 0) {
-    logger.info("No changes detected");
-    return;
-  }
-  logger.heading("Changes detected:");
-  for (const change of changes) {
-    logger.file(change.status === "modified" ? "modify" : "delete", change.path);
-  }
-  logger.blank();
-  const message = messageArg || options.message;
-  const result = await syncFiles(tuckDir, changes, { ...options, message });
-  logger.blank();
-  logger.success(`Synced ${changes.length} file${changes.length > 1 ? "s" : ""}`);
-  if (result.commitHash) {
-    logger.info(`Commit: ${result.commitHash.slice(0, 7)}`);
-    if (options.push !== false && await hasRemote(tuckDir)) {
-      await withSpinner("Pushing to remote...", async () => {
-        await push(tuckDir);
-      });
-      logger.success("Pushed to remote");
-    } else if (options.push === false) {
-      logger.info("Run 'tuck push' when ready to upload");
-    }
-  }
-};
-var syncCommand = new Command4("sync").description("Sync changes to repository (commits and pushes)").argument("[message]", "Commit message").option("-m, --message <msg>", "Commit message").option("-a, --all", "Sync all tracked files, not just changed").option("--no-commit", "Stage changes but don't commit").option("--no-push", "Commit but don't push to remote").option("--amend", "Amend previous commit").option("--no-hooks", "Skip execution of pre/post sync hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (messageArg, options) => {
-  await runSync(messageArg, options);
-});
+// src/commands/index.ts
+init_sync();
 
 // src/commands/push.ts
 init_ui();
@@ -3568,8 +4056,8 @@ init_paths();
 init_manifest();
 init_git();
 init_errors();
-import { Command as Command5 } from "commander";
-import chalk10 from "chalk";
+import { Command as Command6 } from "commander";
+import chalk12 from "chalk";
 var runInteractivePush = async (tuckDir) => {
   prompts.intro("tuck push");
   const hasRemoteRepo = await hasRemote(tuckDir);
@@ -3598,13 +4086,13 @@ var runInteractivePush = async (tuckDir) => {
     return;
   }
   console.log();
-  console.log(chalk10.dim("Remote:"), remoteUrl);
-  console.log(chalk10.dim("Branch:"), branch);
+  console.log(chalk12.dim("Remote:"), remoteUrl);
+  console.log(chalk12.dim("Branch:"), branch);
   if (status.ahead > 0) {
-    console.log(chalk10.dim("Commits:"), chalk10.green(`\u2191 ${status.ahead} to push`));
+    console.log(chalk12.dim("Commits:"), chalk12.green(`\u2191 ${status.ahead} to push`));
   }
   if (status.behind > 0) {
-    console.log(chalk10.dim("Warning:"), chalk10.yellow(`\u2193 ${status.behind} commits behind remote`));
+    console.log(chalk12.dim("Warning:"), chalk12.yellow(`\u2193 ${status.behind} commits behind remote`));
     const pullFirst = await prompts.confirm("Pull changes first?", true);
     if (pullFirst) {
       prompts.log.info("Run 'tuck pull' first, then push");
@@ -3618,20 +4106,39 @@ var runInteractivePush = async (tuckDir) => {
     return;
   }
   const needsUpstream = !status.tracking;
-  await withSpinner("Pushing...", async () => {
-    await push(tuckDir, {
-      setUpstream: needsUpstream,
-      branch: needsUpstream ? branch : void 0
+  try {
+    await withSpinner("Pushing...", async () => {
+      await push(tuckDir, {
+        setUpstream: needsUpstream,
+        branch: needsUpstream ? branch : void 0
+      });
     });
-  });
-  prompts.log.success("Pushed successfully!");
+    prompts.log.success("Pushed successfully!");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    if (errorMsg.includes("Permission denied") || errorMsg.includes("publickey")) {
+      prompts.log.error("Authentication failed");
+      prompts.log.info("Check your SSH keys with: ssh -T git@github.com");
+      prompts.log.info("Or try switching to HTTPS: git remote set-url origin https://...");
+    } else if (errorMsg.includes("Could not resolve host") || errorMsg.includes("Network")) {
+      prompts.log.error("Network error - could not reach remote");
+      prompts.log.info("Check your internet connection and try again");
+    } else if (errorMsg.includes("rejected") || errorMsg.includes("non-fast-forward")) {
+      prompts.log.error("Push rejected - remote has changes");
+      prompts.log.info("Run 'tuck pull' first, then push again");
+      prompts.log.info("Or use 'tuck push --force' to overwrite (use with caution)");
+    } else {
+      prompts.log.error(`Push failed: ${errorMsg}`);
+    }
+    return;
+  }
   if (remoteUrl) {
     let viewUrl = remoteUrl;
     if (remoteUrl.startsWith("git@github.com:")) {
       viewUrl = remoteUrl.replace("git@github.com:", "https://github.com/").replace(".git", "");
     }
     console.log();
-    console.log(chalk10.dim("View at:"), chalk10.cyan(viewUrl));
+    console.log(chalk12.dim("View at:"), chalk12.cyan(viewUrl));
   }
   prompts.outro("");
 };
@@ -3651,16 +4158,29 @@ var runPush = async (options) => {
     throw new GitError("No remote configured", "Run 'tuck init -r <url>' or add a remote manually");
   }
   const branch = await getCurrentBranch(tuckDir);
-  await withSpinner("Pushing...", async () => {
-    await push(tuckDir, {
-      force: options.force,
-      setUpstream: Boolean(options.setUpstream),
-      branch: options.setUpstream || branch
+  try {
+    await withSpinner("Pushing...", async () => {
+      await push(tuckDir, {
+        force: options.force,
+        setUpstream: Boolean(options.setUpstream),
+        branch: options.setUpstream || branch
+      });
     });
-  });
-  logger.success("Pushed successfully!");
+    logger.success("Pushed successfully!");
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    if (errorMsg.includes("Permission denied") || errorMsg.includes("publickey")) {
+      throw new GitError("Authentication failed", "Check your SSH keys: ssh -T git@github.com");
+    } else if (errorMsg.includes("Could not resolve host") || errorMsg.includes("Network")) {
+      throw new GitError("Network error", "Check your internet connection");
+    } else if (errorMsg.includes("rejected") || errorMsg.includes("non-fast-forward")) {
+      throw new GitError("Push rejected", "Run 'tuck pull' first, or use --force");
+    } else {
+      throw new GitError("Push failed", errorMsg);
+    }
+  }
 };
-var pushCommand = new Command5("push").description("Push changes to remote repository").option("-f, --force", "Force push").option("--set-upstream <name>", "Set upstream branch").action(async (options) => {
+var pushCommand = new Command6("push").description("Push changes to remote repository").option("-f, --force", "Force push").option("--set-upstream <name>", "Set upstream branch").action(async (options) => {
   await runPush(options);
 });
 
@@ -3670,8 +4190,8 @@ init_paths();
 init_manifest();
 init_git();
 init_errors();
-import { Command as Command6 } from "commander";
-import chalk11 from "chalk";
+import { Command as Command7 } from "commander";
+import chalk13 from "chalk";
 var runInteractivePull = async (tuckDir) => {
   prompts.intro("tuck pull");
   const hasRemoteRepo = await hasRemote(tuckDir);
@@ -3687,23 +4207,23 @@ var runInteractivePull = async (tuckDir) => {
   const branch = await getCurrentBranch(tuckDir);
   const remoteUrl = await getRemoteUrl(tuckDir);
   console.log();
-  console.log(chalk11.dim("Remote:"), remoteUrl);
-  console.log(chalk11.dim("Branch:"), branch);
+  console.log(chalk13.dim("Remote:"), remoteUrl);
+  console.log(chalk13.dim("Branch:"), branch);
   if (status.behind === 0) {
     prompts.log.success("Already up to date");
     return;
   }
-  console.log(chalk11.dim("Commits:"), chalk11.yellow(`\u2193 ${status.behind} to pull`));
+  console.log(chalk13.dim("Commits:"), chalk13.yellow(`\u2193 ${status.behind} to pull`));
   if (status.ahead > 0) {
     console.log(
-      chalk11.dim("Note:"),
-      chalk11.yellow(`You also have ${status.ahead} local commit${status.ahead > 1 ? "s" : ""} to push`)
+      chalk13.dim("Note:"),
+      chalk13.yellow(`You also have ${status.ahead} local commit${status.ahead > 1 ? "s" : ""} to push`)
     );
   }
   if (status.modified.length > 0 || status.staged.length > 0) {
     console.log();
     prompts.log.warning("You have uncommitted changes");
-    console.log(chalk11.dim("Modified:"), status.modified.join(", "));
+    console.log(chalk13.dim("Modified:"), status.modified.join(", "));
     const continueAnyway = await prompts.confirm("Pull anyway? (may cause merge conflicts)");
     if (!continueAnyway) {
       prompts.cancel("Commit or stash your changes first with 'tuck sync'");
@@ -3748,249 +4268,12 @@ var runPull = async (options) => {
     logger.info("Run 'tuck restore --all' to restore dotfiles");
   }
 };
-var pullCommand = new Command6("pull").description("Pull changes from remote").option("--rebase", "Pull with rebase").option("--restore", "Also restore files to system after pull").action(async (options) => {
+var pullCommand = new Command7("pull").description("Pull changes from remote").option("--rebase", "Pull with rebase").option("--restore", "Also restore files to system after pull").action(async (options) => {
   await runPull(options);
 });
 
-// src/commands/restore.ts
-init_ui();
-init_paths();
-init_manifest();
-init_config();
-init_files();
-import { Command as Command7 } from "commander";
-import chalk12 from "chalk";
-import { join as join11 } from "path";
-import { chmod, stat as stat5 } from "fs/promises";
-
-// src/lib/backup.ts
-import { join as join10 } from "path";
-init_constants();
-init_paths();
-import { copy as copy4, ensureDir as ensureDir4, pathExists as pathExists3 } from "fs-extra";
-var getBackupDir = () => {
-  return expandPath(BACKUP_DIR);
-};
-var formatDateForBackup = (date) => {
-  return date.toISOString().slice(0, 10);
-};
-var getTimestampedBackupDir = (date) => {
-  const backupRoot = getBackupDir();
-  const timestamp = formatDateForBackup(date);
-  return join10(backupRoot, timestamp);
-};
-var createBackup = async (sourcePath, customBackupDir) => {
-  const expandedSource = expandPath(sourcePath);
-  const date = /* @__PURE__ */ new Date();
-  if (!await pathExists(expandedSource)) {
-    throw new Error(`Source path does not exist: ${sourcePath}`);
-  }
-  const backupRoot = customBackupDir ? expandPath(customBackupDir) : getTimestampedBackupDir(date);
-  await ensureDir4(backupRoot);
-  const collapsed = collapsePath(expandedSource);
-  const backupName = collapsed.replace(/^~\//, "").replace(/\//g, "_").replace(/^\./, "dot-");
-  const timestamp = date.toISOString().replace(/[:.]/g, "-").slice(11, 19);
-  const backupPath = join10(backupRoot, `${backupName}_${timestamp}`);
-  await copy4(expandedSource, backupPath, { overwrite: true });
-  return {
-    originalPath: expandedSource,
-    backupPath,
-    date
-  };
-};
-
-// src/commands/restore.ts
-init_errors();
-init_constants();
-var fixSSHPermissions = async (path) => {
-  const expandedPath = expandPath(path);
-  if (!path.includes(".ssh/") && !path.endsWith(".ssh")) {
-    return;
-  }
-  try {
-    const stats = await stat5(expandedPath);
-    if (stats.isDirectory()) {
-      await chmod(expandedPath, 448);
-    } else {
-      await chmod(expandedPath, 384);
-    }
-  } catch {
-  }
-};
-var fixGPGPermissions = async (path) => {
-  const expandedPath = expandPath(path);
-  if (!path.includes(".gnupg/") && !path.endsWith(".gnupg")) {
-    return;
-  }
-  try {
-    const stats = await stat5(expandedPath);
-    if (stats.isDirectory()) {
-      await chmod(expandedPath, 448);
-    } else {
-      await chmod(expandedPath, 384);
-    }
-  } catch {
-  }
-};
-var prepareFilesToRestore = async (tuckDir, paths) => {
-  const allFiles = await getAllTrackedFiles(tuckDir);
-  const filesToRestore = [];
-  if (paths && paths.length > 0) {
-    for (const path of paths) {
-      const expandedPath = expandPath(path);
-      const collapsedPath = collapsePath(expandedPath);
-      const tracked = await getTrackedFileBySource(tuckDir, collapsedPath);
-      if (!tracked) {
-        throw new FileNotFoundError(`Not tracked: ${path}`);
-      }
-      filesToRestore.push({
-        id: tracked.id,
-        source: tracked.file.source,
-        destination: join11(tuckDir, tracked.file.destination),
-        category: tracked.file.category,
-        existsAtTarget: await pathExists(expandedPath)
-      });
-    }
-  } else {
-    for (const [id, file] of Object.entries(allFiles)) {
-      const targetPath = expandPath(file.source);
-      filesToRestore.push({
-        id,
-        source: file.source,
-        destination: join11(tuckDir, file.destination),
-        category: file.category,
-        existsAtTarget: await pathExists(targetPath)
-      });
-    }
-  }
-  return filesToRestore;
-};
-var restoreFiles = async (tuckDir, files, options) => {
-  const config = await loadConfig(tuckDir);
-  const useSymlink = options.symlink || config.files.strategy === "symlink";
-  const shouldBackup = options.backup ?? config.files.backupOnRestore;
-  const hookOptions = {
-    skipHooks: options.noHooks,
-    trustHooks: options.trustHooks
-  };
-  await runPreRestoreHook(tuckDir, hookOptions);
-  let restoredCount = 0;
-  for (const file of files) {
-    const targetPath = expandPath(file.source);
-    if (!await pathExists(file.destination)) {
-      logger.warning(`Source not found in repository: ${file.source}`);
-      continue;
-    }
-    if (options.dryRun) {
-      if (file.existsAtTarget) {
-        logger.file("modify", `${file.source} (would overwrite)`);
-      } else {
-        logger.file("add", `${file.source} (would create)`);
-      }
-      continue;
-    }
-    if (shouldBackup && file.existsAtTarget) {
-      await withSpinner(`Backing up ${file.source}...`, async () => {
-        await createBackup(targetPath);
-      });
-    }
-    await withSpinner(`Restoring ${file.source}...`, async () => {
-      if (useSymlink) {
-        await createSymlink(file.destination, targetPath, { overwrite: true });
-      } else {
-        await copyFileOrDir(file.destination, targetPath, { overwrite: true });
-      }
-      await fixSSHPermissions(file.source);
-      await fixGPGPermissions(file.source);
-    });
-    restoredCount++;
-  }
-  await runPostRestoreHook(tuckDir, hookOptions);
-  return restoredCount;
-};
-var runInteractiveRestore = async (tuckDir) => {
-  prompts.intro("tuck restore");
-  const files = await prepareFilesToRestore(tuckDir);
-  if (files.length === 0) {
-    prompts.log.warning("No files to restore");
-    prompts.note("Run 'tuck add <path>' to track files first", "Tip");
-    return;
-  }
-  const fileOptions = files.map((file) => {
-    const categoryConfig = CATEGORIES[file.category] || { icon: "\u{1F4C4}" };
-    const status = file.existsAtTarget ? chalk12.yellow("(exists, will backup)") : "";
-    return {
-      value: file.id,
-      label: `${categoryConfig.icon} ${file.source} ${status}`,
-      hint: file.category
-    };
-  });
-  const selectedIds = await prompts.multiselect("Select files to restore:", fileOptions, true);
-  if (selectedIds.length === 0) {
-    prompts.cancel("No files selected");
-    return;
-  }
-  const selectedFiles = files.filter((f) => selectedIds.includes(f.id));
-  const existingFiles = selectedFiles.filter((f) => f.existsAtTarget);
-  if (existingFiles.length > 0) {
-    console.log();
-    prompts.log.warning(
-      `${existingFiles.length} file${existingFiles.length > 1 ? "s" : ""} will be backed up:`
-    );
-    existingFiles.forEach((f) => console.log(chalk12.dim(`  ${f.source}`)));
-    console.log();
-  }
-  const useSymlink = await prompts.select("Restore method:", [
-    { value: false, label: "Copy files", hint: "Recommended" },
-    { value: true, label: "Create symlinks", hint: "Files stay in tuck repo" }
-  ]);
-  const confirm2 = await prompts.confirm(
-    `Restore ${selectedFiles.length} file${selectedFiles.length > 1 ? "s" : ""}?`,
-    true
-  );
-  if (!confirm2) {
-    prompts.cancel("Operation cancelled");
-    return;
-  }
-  const restoredCount = await restoreFiles(tuckDir, selectedFiles, {
-    symlink: useSymlink,
-    backup: true
-  });
-  console.log();
-  prompts.outro(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
-};
-var runRestore = async (paths, options) => {
-  const tuckDir = getTuckDir();
-  try {
-    await loadManifest(tuckDir);
-  } catch {
-    throw new NotInitializedError();
-  }
-  if (paths.length === 0 && !options.all) {
-    await runInteractiveRestore(tuckDir);
-    return;
-  }
-  const files = await prepareFilesToRestore(tuckDir, options.all ? void 0 : paths);
-  if (files.length === 0) {
-    logger.warning("No files to restore");
-    return;
-  }
-  if (options.dryRun) {
-    logger.heading("Dry run - would restore:");
-  } else {
-    logger.heading("Restoring:");
-  }
-  const restoredCount = await restoreFiles(tuckDir, files, options);
-  logger.blank();
-  if (options.dryRun) {
-    logger.info(`Would restore ${files.length} file${files.length > 1 ? "s" : ""}`);
-  } else {
-    logger.success(`Restored ${restoredCount} file${restoredCount > 1 ? "s" : ""}`);
-  }
-};
-var restoreCommand = new Command7("restore").description("Restore dotfiles to the system").argument("[paths...]", "Paths to restore (or use --all)").option("-a, --all", "Restore all tracked files").option("--symlink", "Create symlinks instead of copies").option("--backup", "Backup existing files before restore").option("--no-backup", "Skip backup of existing files").option("--dry-run", "Show what would be done").option("--no-hooks", "Skip execution of pre/post restore hooks").option("--trust-hooks", "Trust and run hooks without confirmation (use with caution)").action(async (paths, options) => {
-  await runRestore(paths, options);
-});
+// src/commands/index.ts
+init_restore();
 
 // src/commands/status.ts
 init_ui();
@@ -3999,8 +4282,10 @@ init_manifest();
 init_git();
 init_files();
 init_errors();
+init_constants();
 import { Command as Command8 } from "commander";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
+import boxen2 from "boxen";
 var detectFileChanges = async (tuckDir) => {
   const files = await getAllTrackedFiles(tuckDir);
   const changes = [];
@@ -4055,6 +4340,10 @@ var getFullStatus = async (tuckDir) => {
     }
   }
   const fileChanges = await detectFileChanges(tuckDir);
+  const categoryCounts = {};
+  for (const file of Object.values(manifest.files)) {
+    categoryCounts[file.category] = (categoryCounts[file.category] || 0) + 1;
+  }
   return {
     tuckDir,
     branch,
@@ -4063,6 +4352,7 @@ var getFullStatus = async (tuckDir) => {
     ahead: gitStatus.ahead,
     behind: gitStatus.behind,
     trackedCount: Object.keys(manifest.files).length,
+    categoryCounts,
     changes: fileChanges,
     gitChanges: {
       staged: gitStatus.staged,
@@ -4072,56 +4362,81 @@ var getFullStatus = async (tuckDir) => {
   };
 };
 var printStatus = (status) => {
-  prompts.intro("tuck status");
-  console.log();
-  console.log(chalk13.dim("Repository:"), collapsePath(status.tuckDir));
-  console.log(chalk13.dim("Branch:"), chalk13.cyan(status.branch));
+  const headerLines = [
+    `${chalk14.bold.cyan("tuck")} ${chalk14.dim(`v${VERSION}`)}`,
+    "",
+    `${chalk14.dim("Repository:")} ${collapsePath(status.tuckDir)}`,
+    `${chalk14.dim("Branch:")}     ${chalk14.cyan(status.branch)}`
+  ];
+  if (status.remote) {
+    const shortRemote = status.remote.length > 40 ? status.remote.replace(/^https?:\/\//, "").replace(/\.git$/, "") : status.remote;
+    headerLines.push(`${chalk14.dim("Remote:")}     ${shortRemote}`);
+  } else {
+    headerLines.push(`${chalk14.dim("Remote:")}     ${chalk14.yellow("not configured")}`);
+  }
+  console.log(boxen2(headerLines.join("\n"), {
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+    borderColor: "cyan",
+    borderStyle: "round"
+  }));
   if (status.remote) {
-    console.log(chalk13.dim("Remote:"), status.remote);
     let remoteInfo = "";
     switch (status.remoteStatus) {
       case "up-to-date":
-        remoteInfo = chalk13.green("up to date");
+        remoteInfo = chalk14.green("\u2713 Up to date with remote");
         break;
       case "ahead":
-        remoteInfo = chalk13.yellow(`${status.ahead} commit${status.ahead > 1 ? "s" : ""} ahead`);
+        remoteInfo = chalk14.yellow(`\u2191 ${status.ahead} commit${status.ahead > 1 ? "s" : ""} ahead of remote`);
         break;
       case "behind":
-        remoteInfo = chalk13.yellow(`${status.behind} commit${status.behind > 1 ? "s" : ""} behind`);
+        remoteInfo = chalk14.yellow(`\u2193 ${status.behind} commit${status.behind > 1 ? "s" : ""} behind remote`);
         break;
       case "diverged":
-        remoteInfo = chalk13.red(`diverged (${status.ahead} ahead, ${status.behind} behind)`);
+        remoteInfo = chalk14.red(`\u26A0 Diverged (${status.ahead} ahead, ${status.behind} behind)`);
         break;
     }
-    console.log(chalk13.dim("Status:"), remoteInfo);
-  } else {
-    console.log(chalk13.dim("Remote:"), chalk13.yellow("not configured"));
+    console.log("\n" + remoteInfo);
   }
   console.log();
-  console.log(chalk13.dim("Tracked files:"), status.trackedCount);
+  console.log(chalk14.bold(`Tracked Files: ${status.trackedCount}`));
+  const categoryOrder = ["shell", "git", "editors", "terminal", "ssh", "misc"];
+  const sortedCategories = Object.keys(status.categoryCounts).sort((a, b) => {
+    const aIdx = categoryOrder.indexOf(a);
+    const bIdx = categoryOrder.indexOf(b);
+    if (aIdx === -1 && bIdx === -1) return a.localeCompare(b);
+    if (aIdx === -1) return 1;
+    if (bIdx === -1) return -1;
+    return aIdx - bIdx;
+  });
+  if (sortedCategories.length > 0) {
+    for (const category of sortedCategories) {
+      const count = status.categoryCounts[category];
+      console.log(chalk14.dim(`  ${category}: ${count} file${count > 1 ? "s" : ""}`));
+    }
+  }
   if (status.changes.length > 0) {
     console.log();
-    console.log(chalk13.bold("Changes detected:"));
+    console.log(chalk14.bold("Changes detected:"));
     for (const change of status.changes) {
       const statusText = formatStatus(change.status);
-      console.log(`  ${statusText}: ${chalk13.cyan(change.path)}`);
+      console.log(`  ${statusText}: ${chalk14.cyan(change.path)}`);
     }
   }
   const hasGitChanges = status.gitChanges.staged.length > 0 || status.gitChanges.modified.length > 0 || status.gitChanges.untracked.length > 0;
   if (hasGitChanges) {
     console.log();
-    console.log(chalk13.bold("Repository changes:"));
+    console.log(chalk14.bold("Repository changes:"));
     if (status.gitChanges.staged.length > 0) {
-      console.log(chalk13.green("  Staged:"));
-      status.gitChanges.staged.forEach((f) => console.log(chalk13.green(`    + ${f}`)));
+      console.log(chalk14.green("  Staged:"));
+      status.gitChanges.staged.forEach((f) => console.log(chalk14.green(`    + ${f}`)));
     }
     if (status.gitChanges.modified.length > 0) {
-      console.log(chalk13.yellow("  Modified:"));
-      status.gitChanges.modified.forEach((f) => console.log(chalk13.yellow(`    ~ ${f}`)));
+      console.log(chalk14.yellow("  Modified:"));
+      status.gitChanges.modified.forEach((f) => console.log(chalk14.yellow(`    ~ ${f}`)));
     }
     if (status.gitChanges.untracked.length > 0) {
-      console.log(chalk13.dim("  Untracked:"));
-      status.gitChanges.untracked.forEach((f) => console.log(chalk13.dim(`    ? ${f}`)));
+      console.log(chalk14.dim("  Untracked:"));
+      status.gitChanges.untracked.forEach((f) => console.log(chalk14.dim(`    ? ${f}`)));
     }
   }
   console.log();
@@ -4186,7 +4501,7 @@ init_manifest();
 init_errors();
 init_constants();
 import { Command as Command9 } from "commander";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 var groupByCategory = async (tuckDir) => {
   const files = await getAllTrackedFiles(tuckDir);
   const groups = /* @__PURE__ */ new Map();
@@ -4225,15 +4540,15 @@ var printList = (groups) => {
     totalFiles += fileCount;
     console.log();
     console.log(
-      chalk14.bold(`${group2.icon} ${group2.name}`) + chalk14.dim(` (${formatCount(fileCount, "file")})`)
+      chalk15.bold(`${group2.icon} ${group2.name}`) + chalk15.dim(` (${formatCount(fileCount, "file")})`)
     );
     group2.files.forEach((file, index) => {
       const isLast = index === group2.files.length - 1;
       const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
       const name = file.source.split("/").pop() || file.source;
-      const arrow = chalk14.dim(" \u2192 ");
-      const dest = chalk14.dim(file.source);
-      console.log(chalk14.dim(prefix) + chalk14.cyan(name) + arrow + dest);
+      const arrow = chalk15.dim(" \u2192 ");
+      const dest = chalk15.dim(file.source);
+      console.log(chalk15.dim(prefix) + chalk15.cyan(name) + arrow + dest);
     });
   }
   console.log();
@@ -4294,7 +4609,7 @@ init_git();
 init_files();
 init_errors();
 import { Command as Command10 } from "commander";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import { join as join12 } from "path";
 import { readFile as readFile6 } from "fs/promises";
 var getFileDiff = async (tuckDir, source) => {
@@ -4332,19 +4647,19 @@ var getFileDiff = async (tuckDir, source) => {
 };
 var formatUnifiedDiff = (source, systemContent, repoContent) => {
   const lines = [];
-  lines.push(chalk15.bold(`--- a/${source} (system)`));
-  lines.push(chalk15.bold(`+++ b/${source} (repository)`));
+  lines.push(chalk16.bold(`--- a/${source} (system)`));
+  lines.push(chalk16.bold(`+++ b/${source} (repository)`));
   if (!systemContent && repoContent) {
-    lines.push(chalk15.red("File missing on system"));
-    lines.push(chalk15.dim("Repository content:"));
+    lines.push(chalk16.red("File missing on system"));
+    lines.push(chalk16.dim("Repository content:"));
     repoContent.split("\n").forEach((line) => {
-      lines.push(chalk15.green(`+ ${line}`));
+      lines.push(chalk16.green(`+ ${line}`));
     });
   } else if (systemContent && !repoContent) {
-    lines.push(chalk15.yellow("File not yet synced to repository"));
-    lines.push(chalk15.dim("System content:"));
+    lines.push(chalk16.yellow("File not yet synced to repository"));
+    lines.push(chalk16.dim("System content:"));
     systemContent.split("\n").forEach((line) => {
-      lines.push(chalk15.red(`- ${line}`));
+      lines.push(chalk16.red(`- ${line}`));
     });
   } else if (systemContent && repoContent) {
     const systemLines = systemContent.split("\n");
@@ -4359,16 +4674,16 @@ var formatUnifiedDiff = (source, systemContent, repoContent) => {
         if (!inDiff) {
           inDiff = true;
           diffStart = i;
-          lines.push(chalk15.cyan(`@@ -${i + 1} +${i + 1} @@`));
+          lines.push(chalk16.cyan(`@@ -${i + 1} +${i + 1} @@`));
         }
         if (sysLine !== void 0) {
-          lines.push(chalk15.red(`- ${sysLine}`));
+          lines.push(chalk16.red(`- ${sysLine}`));
         }
         if (repoLine !== void 0) {
-          lines.push(chalk15.green(`+ ${repoLine}`));
+          lines.push(chalk16.green(`+ ${repoLine}`));
         }
       } else if (inDiff) {
-        lines.push(chalk15.dim(`  ${sysLine || ""}`));
+        lines.push(chalk16.dim(`  ${sysLine || ""}`));
         if (i - diffStart > 3) {
           inDiff = false;
         }
@@ -4409,10 +4724,10 @@ var runDiff = async (paths, options) => {
     if (options.stat) {
       prompts.intro("tuck diff");
       console.log();
-      console.log(chalk15.bold(`${changedFiles.length} file${changedFiles.length > 1 ? "s" : ""} changed:`));
+      console.log(chalk16.bold(`${changedFiles.length} file${changedFiles.length > 1 ? "s" : ""} changed:`));
       console.log();
       for (const diff of changedFiles) {
-        console.log(chalk15.yellow(`  ~ ${diff.source}`));
+        console.log(chalk16.yellow(`  ~ ${diff.source}`));
       }
       console.log();
       return;
@@ -4433,7 +4748,7 @@ var runDiff = async (paths, options) => {
       continue;
     }
     if (options.stat) {
-      console.log(chalk15.yellow(`~ ${path}`));
+      console.log(chalk16.yellow(`~ ${path}`));
     } else {
       console.log(formatUnifiedDiff(path, diff.systemContent, diff.repoContent));
       console.log();
@@ -4451,7 +4766,7 @@ init_config();
 init_manifest();
 init_errors();
 import { Command as Command11 } from "commander";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import { spawn } from "child_process";
 var printConfig = (config) => {
   console.log(JSON.stringify(config, null, 2));
@@ -4517,7 +4832,7 @@ var runConfigList = async () => {
   const config = await loadConfig(tuckDir);
   prompts.intro("tuck config");
   console.log();
-  console.log(chalk16.dim("Configuration file:"), collapsePath(getConfigPath(tuckDir)));
+  console.log(chalk17.dim("Configuration file:"), collapsePath(getConfigPath(tuckDir)));
   console.log();
   printConfig(config);
 };
@@ -4613,9 +4928,9 @@ init_github();
 import { Command as Command12 } from "commander";
 import { join as join13 } from "path";
 import { readFile as readFile8, rm as rm4, chmod as chmod2, stat as stat6 } from "fs/promises";
-import { ensureDir as ensureDir5, pathExists as fsPathExists } from "fs-extra";
+import { ensureDir as ensureDir6, pathExists as fsPathExists } from "fs-extra";
 import { tmpdir as tmpdir2 } from "os";
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 
 // src/lib/merge.ts
 init_paths();
@@ -4881,7 +5196,7 @@ var resolveSource = async (source) => {
 };
 var cloneSource = async (repoId, isUrl) => {
   const tempDir = join13(tmpdir2(), `tuck-apply-${Date.now()}`);
-  await ensureDir5(tempDir);
+  await ensureDir6(tempDir);
   if (isUrl) {
     await cloneRepo(repoId, tempDir);
   } else {
@@ -4937,9 +5252,9 @@ var applyWithMerge = async (files, dryRun) => {
         logger.file("merge", `${collapsePath(file.destination)} (${mergeResult.preservedBlocks} blocks preserved)`);
       } else {
         const { writeFile: writeFile5 } = await import("fs/promises");
-        const { ensureDir: ensureDir6 } = await import("fs-extra");
-        const { dirname: dirname4 } = await import("path");
-        await ensureDir6(dirname4(file.destination));
+        const { ensureDir: ensureDir7 } = await import("fs-extra");
+        const { dirname: dirname6 } = await import("path");
+        await ensureDir7(dirname6(file.destination));
         await writeFile5(file.destination, mergeResult.content, "utf-8");
         logger.file("merge", collapsePath(file.destination));
       }
@@ -5035,11 +5350,11 @@ var runInteractiveApply = async (source, options) => {
     }
     for (const [category, categoryFiles] of Object.entries(byCategory)) {
       const categoryConfig = CATEGORIES[category] || { icon: "\u{1F4C4}" };
-      console.log(chalk17.bold(`  ${categoryConfig.icon} ${category}`));
+      console.log(chalk18.bold(`  ${categoryConfig.icon} ${category}`));
       for (const file of categoryFiles) {
         const exists = await pathExists(file.destination);
-        const status = exists ? chalk17.yellow("(will update)") : chalk17.green("(new)");
-        console.log(chalk17.dim(`    ${collapsePath(file.destination)} ${status}`));
+        const status = exists ? chalk18.yellow("(will update)") : chalk18.green("(new)");
+        console.log(chalk18.dim(`    ${collapsePath(file.destination)} ${status}`));
       }
     }
     console.log();
@@ -5199,7 +5514,7 @@ var applyCommand = new Command12("apply").description("Apply dotfiles from a rep
 init_ui();
 init_paths();
 import { Command as Command13 } from "commander";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 var showSnapshotList = async () => {
   const snapshots = await listSnapshots();
   if (snapshots.length === 0) {
@@ -5212,11 +5527,11 @@ var showSnapshotList = async () => {
   for (const snapshot of snapshots) {
     const date = formatSnapshotDate(snapshot.id);
     const fileCount = snapshot.files.filter((f) => f.existed).length;
-    console.log(chalk18.cyan(`  ${snapshot.id}`));
-    console.log(chalk18.dim(`    Date:    ${date}`));
-    console.log(chalk18.dim(`    Reason:  ${snapshot.reason}`));
-    console.log(chalk18.dim(`    Files:   ${fileCount} file(s) backed up`));
-    console.log(chalk18.dim(`    Machine: ${snapshot.machine}`));
+    console.log(chalk19.cyan(`  ${snapshot.id}`));
+    console.log(chalk19.dim(`    Date:    ${date}`));
+    console.log(chalk19.dim(`    Reason:  ${snapshot.reason}`));
+    console.log(chalk19.dim(`    Files:   ${fileCount} file(s) backed up`));
+    console.log(chalk19.dim(`    Machine: ${snapshot.machine}`));
     console.log();
   }
   const totalSize = await getSnapshotsSize();
@@ -5227,18 +5542,18 @@ var showSnapshotList = async () => {
 };
 var showSnapshotDetails = (snapshot) => {
   console.log();
-  console.log(chalk18.bold("Snapshot Details:"));
-  console.log(chalk18.dim(`  ID:      ${snapshot.id}`));
-  console.log(chalk18.dim(`  Date:    ${formatSnapshotDate(snapshot.id)}`));
-  console.log(chalk18.dim(`  Reason:  ${snapshot.reason}`));
-  console.log(chalk18.dim(`  Machine: ${snapshot.machine}`));
+  console.log(chalk19.bold("Snapshot Details:"));
+  console.log(chalk19.dim(`  ID:      ${snapshot.id}`));
+  console.log(chalk19.dim(`  Date:    ${formatSnapshotDate(snapshot.id)}`));
+  console.log(chalk19.dim(`  Reason:  ${snapshot.reason}`));
+  console.log(chalk19.dim(`  Machine: ${snapshot.machine}`));
   console.log();
-  console.log(chalk18.bold("Files in snapshot:"));
+  console.log(chalk19.bold("Files in snapshot:"));
   for (const file of snapshot.files) {
     if (file.existed) {
-      console.log(chalk18.dim(`  ok ${collapsePath(file.originalPath)}`));
+      console.log(chalk19.dim(`  ok ${collapsePath(file.originalPath)}`));
     } else {
-      console.log(chalk18.dim(`  - ${collapsePath(file.originalPath)} (did not exist)`));
+      console.log(chalk19.dim(`  - ${collapsePath(file.originalPath)} (did not exist)`));
     }
   }
   console.log();
@@ -5346,11 +5661,11 @@ var runInteractiveUndo = async () => {
   prompts.log.info("Files in this snapshot:");
   for (const file of snapshot.files.slice(0, 10)) {
     if (file.existed) {
-      console.log(chalk18.dim(`  ${collapsePath(file.originalPath)}`));
+      console.log(chalk19.dim(`  ${collapsePath(file.originalPath)}`));
     }
   }
   if (snapshot.files.length > 10) {
-    console.log(chalk18.dim(`  ... and ${snapshot.files.length - 10} more`));
+    console.log(chalk19.dim(`  ... and ${snapshot.files.length - 10} more`));
   }
   console.log();
   const confirmed = await prompts.confirm("Restore these files?", true);
@@ -5401,7 +5716,7 @@ init_ui();
 init_paths();
 init_manifest();
 import { Command as Command14 } from "commander";
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 init_errors();
 var groupSelectableByCategory = (files) => {
   const grouped = {};
@@ -5426,18 +5741,18 @@ var displayGroupedFiles = (files, showAll) => {
     const trackedFiles = categoryFiles.filter((f) => f.alreadyTracked);
     console.log();
     console.log(
-      chalk19.bold(`${config.icon} ${config.name}`) + chalk19.dim(` (${newFiles.length} new, ${trackedFiles.length} tracked)`)
+      chalk20.bold(`${config.icon} ${config.name}`) + chalk20.dim(` (${newFiles.length} new, ${trackedFiles.length} tracked)`)
     );
-    console.log(chalk19.dim("\u2500".repeat(50)));
+    console.log(chalk20.dim("\u2500".repeat(50)));
     for (const file of categoryFiles) {
       if (!showAll && file.alreadyTracked) continue;
-      const status = file.selected ? chalk19.green("[x]") : chalk19.dim("[ ]");
+      const status = file.selected ? chalk20.green("[x]") : chalk20.dim("[ ]");
       const name = file.path;
-      const tracked = file.alreadyTracked ? chalk19.dim(" (tracked)") : "";
-      const sensitive = file.sensitive ? chalk19.yellow(" [!]") : "";
-      const dir = file.isDirectory ? chalk19.cyan(" [dir]") : "";
+      const tracked = file.alreadyTracked ? chalk20.dim(" (tracked)") : "";
+      const sensitive = file.sensitive ? chalk20.yellow(" [!]") : "";
+      const dir = file.isDirectory ? chalk20.cyan(" [dir]") : "";
       console.log(`  ${status} ${name}${dir}${sensitive}${tracked}`);
-      console.log(chalk19.dim(`      ${file.description}`));
+      console.log(chalk20.dim(`      ${file.description}`));
     }
   }
 };
@@ -5452,16 +5767,16 @@ var runInteractiveSelection = async (files) => {
   for (const [category, categoryFiles] of Object.entries(grouped)) {
     const config = DETECTION_CATEGORIES[category] || { icon: "-", name: category };
     console.log();
-    console.log(chalk19.bold(`${config.icon} ${config.name}`));
-    console.log(chalk19.dim(config.description || ""));
+    console.log(chalk20.bold(`${config.icon} ${config.name}`));
+    console.log(chalk20.dim(config.description || ""));
     console.log();
     const options = categoryFiles.map((file) => {
       let label = file.path;
       if (file.sensitive) {
-        label += chalk19.yellow(" [!]");
+        label += chalk20.yellow(" [!]");
       }
       if (file.isDirectory) {
-        label += chalk19.cyan(" [dir]");
+        label += chalk20.cyan(" [dir]");
       }
       return {
         value: file.path,
@@ -5487,11 +5802,11 @@ var runQuickScan = async (files) => {
   const trackedFiles = files.filter((f) => f.alreadyTracked);
   console.log();
   console.log(
-    chalk19.bold.cyan("Detected Dotfiles: ") + chalk19.white(`${newFiles.length} new, ${trackedFiles.length} already tracked`)
+    chalk20.bold.cyan("Detected Dotfiles: ") + chalk20.white(`${newFiles.length} new, ${trackedFiles.length} already tracked`)
   );
   displayGroupedFiles(files, false);
   console.log();
-  console.log(chalk19.dim("\u2500".repeat(60)));
+  console.log(chalk20.dim("\u2500".repeat(60)));
   console.log();
   if (newFiles.length > 0) {
     logger.info(`Found ${newFiles.length} new dotfiles to track`);
@@ -5507,32 +5822,36 @@ var showSummary = (selected) => {
     return;
   }
   console.log();
-  console.log(chalk19.bold.green(`Selected ${selected.length} files to track:`));
+  console.log(chalk20.bold.cyan(`Selected ${selected.length} files to track:`));
+  console.log(chalk20.dim("\u2500".repeat(50)));
   console.log();
   const grouped = groupSelectableByCategory(selected);
   for (const [category, files] of Object.entries(grouped)) {
     const config = DETECTION_CATEGORIES[category] || { icon: "-", name: category };
-    console.log(chalk19.bold(`${config.icon} ${config.name}`));
+    console.log(chalk20.bold(`${config.icon} ${config.name}`));
     for (const file of files) {
-      const sensitive = file.sensitive ? chalk19.yellow(" [!]") : "";
-      console.log(chalk19.dim(`  \u2022 ${file.path}${sensitive}`));
+      const sensitive = file.sensitive ? chalk20.yellow(" \u26A0") : "";
+      console.log(chalk20.dim(`  \u2022 ${collapsePath(file.path)}${sensitive}`));
     }
+    console.log();
   }
-  console.log();
   const sensitiveFiles = selected.filter((f) => f.sensitive);
   if (sensitiveFiles.length > 0) {
-    console.log(chalk19.yellow("Warning: Some selected files may contain sensitive data:"));
-    for (const file of sensitiveFiles) {
-      console.log(chalk19.yellow(`  \u2022 ${file.path}`));
-    }
-    console.log(chalk19.dim("  Make sure your repository is private!"));
+    console.log(chalk20.yellow("\u26A0 Warning: Some files may contain sensitive data"));
+    console.log(chalk20.dim("  Make sure your repository is private!"));
     console.log();
   }
-  const paths = selected.map((f) => f.path).join(" ");
-  console.log(chalk19.bold("Run this command to add the selected files:"));
-  console.log();
-  console.log(chalk19.cyan(`  tuck add ${paths}`));
-  console.log();
+};
+var addFilesWithProgress = async (selected, tuckDir) => {
+  const filesToTrack = selected.map((f) => ({
+    path: f.path,
+    category: f.category
+  }));
+  const result = await trackFilesWithProgress(filesToTrack, tuckDir, {
+    showCategory: true,
+    actionVerb: "Tracking"
+  });
+  return result.succeeded;
 };
 var runScan = async (options) => {
   const tuckDir = getTuckDir();
@@ -5566,7 +5885,7 @@ var runScan = async (options) => {
       logger.warning(`No dotfiles found in category: ${options.category}`);
       logger.info("Available categories:");
       for (const [key, config] of Object.entries(DETECTION_CATEGORIES)) {
-        console.log(chalk19.dim(`  ${config.icon} ${key} - ${config.name}`));
+        console.log(chalk20.dim(`  ${config.icon} ${key} - ${config.name}`));
       }
       return;
     }
@@ -5625,17 +5944,27 @@ var runScan = async (options) => {
   }
   showSummary(selected);
   const confirmed = await prompts.confirm(
-    `Add ${selected.length} files to tuck?`,
+    `Track these ${selected.length} files?`,
     true
   );
   if (!confirmed) {
     prompts.cancel("Operation cancelled");
     return;
   }
-  const { addFilesFromPaths: addFilesFromPaths2 } = await Promise.resolve().then(() => (init_add(), add_exports));
-  const paths = selected.map((f) => f.path);
-  await addFilesFromPaths2(paths, {});
-  prompts.outro(`Added ${selected.length} files to tuck!`);
+  const addedCount = await addFilesWithProgress(selected, tuckDir);
+  if (addedCount > 0) {
+    console.log();
+    const shouldSync = await prompts.confirm("Would you like to sync these changes now?", true);
+    if (shouldSync) {
+      console.log();
+      const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await runSync2({});
+    } else {
+      prompts.outro("Run 'tuck sync' when you're ready to commit changes");
+    }
+  } else {
+    prompts.outro("No files were added");
+  }
 };
 var scanCommand = new Command14("scan").description("Scan system for dotfiles and select which to track").option("-a, --all", "Show all files including already tracked ones").option("-c, --category <name>", "Filter by category (shell, git, editors, etc.)").option("-q, --quick", "Quick scan - just show detected files without interactive selection").option("--json", "Output results as JSON").action(async (options) => {
   await runScan(options);
@@ -5650,7 +5979,7 @@ init_manifest();
 init_git();
 var program = new Command15();
 program.name("tuck").description(DESCRIPTION).version(VERSION, "-v, --version", "Display version number").configureOutput({
-  outputError: (str, write) => write(chalk20.red(str))
+  outputError: (str, write) => write(chalk21.red(str))
 }).addHelpText("beforeAll", customHelp(VERSION)).helpOption("-h, --help", "Display this help message").showHelpAfterError(false);
 program.configureHelp({
   formatHelp: () => ""
@@ -5673,12 +6002,12 @@ var runDefaultAction = async () => {
   const tuckDir = getTuckDir();
   if (!await pathExists(tuckDir)) {
     miniBanner();
-    console.log(chalk20.bold("Get started with tuck:\n"));
-    console.log(chalk20.cyan("  tuck init") + chalk20.dim("   - Set up tuck and create a GitHub repo"));
-    console.log(chalk20.cyan("  tuck scan") + chalk20.dim("   - Find dotfiles to track"));
+    console.log(chalk21.bold("Get started with tuck:\n"));
+    console.log(chalk21.cyan("  tuck init") + chalk21.dim("   - Set up tuck and create a GitHub repo"));
+    console.log(chalk21.cyan("  tuck scan") + chalk21.dim("   - Find dotfiles to track"));
     console.log();
-    console.log(chalk20.dim("On a new machine:"));
-    console.log(chalk20.cyan("  tuck apply <username>") + chalk20.dim(" - Apply your dotfiles"));
+    console.log(chalk21.dim("On a new machine:"));
+    console.log(chalk21.cyan("  tuck apply <username>") + chalk21.dim(" - Apply your dotfiles"));
     console.log();
     return;
   }
@@ -5687,38 +6016,38 @@ var runDefaultAction = async () => {
     const trackedCount = Object.keys(manifest.files).length;
     const gitStatus = await getStatus(tuckDir);
     miniBanner();
-    console.log(chalk20.bold("Status:\n"));
-    console.log(`  Tracked files: ${chalk20.cyan(trackedCount.toString())}`);
+    console.log(chalk21.bold("Status:\n"));
+    console.log(`  Tracked files: ${chalk21.cyan(trackedCount.toString())}`);
     const pendingChanges = gitStatus.modified.length + gitStatus.staged.length;
     if (pendingChanges > 0) {
-      console.log(`  Pending changes: ${chalk20.yellow(pendingChanges.toString())}`);
+      console.log(`  Pending changes: ${chalk21.yellow(pendingChanges.toString())}`);
     } else {
-      console.log(`  Pending changes: ${chalk20.dim("none")}`);
+      console.log(`  Pending changes: ${chalk21.dim("none")}`);
     }
     if (gitStatus.ahead > 0) {
-      console.log(`  Commits to push: ${chalk20.yellow(gitStatus.ahead.toString())}`);
+      console.log(`  Commits to push: ${chalk21.yellow(gitStatus.ahead.toString())}`);
     }
     console.log();
-    console.log(chalk20.bold("Next steps:\n"));
+    console.log(chalk21.bold("Next steps:\n"));
     if (trackedCount === 0) {
-      console.log(chalk20.cyan("  tuck scan") + chalk20.dim("  - Find dotfiles to track"));
-      console.log(chalk20.cyan("  tuck add <file>") + chalk20.dim(" - Track a specific file"));
+      console.log(chalk21.cyan("  tuck scan") + chalk21.dim("  - Find dotfiles to track"));
+      console.log(chalk21.cyan("  tuck add <file>") + chalk21.dim(" - Track a specific file"));
     } else if (pendingChanges > 0) {
-      console.log(chalk20.cyan("  tuck sync") + chalk20.dim("  - Commit and push your changes"));
-      console.log(chalk20.cyan("  tuck diff") + chalk20.dim("  - Preview what changed"));
+      console.log(chalk21.cyan("  tuck sync") + chalk21.dim("  - Commit and push your changes"));
+      console.log(chalk21.cyan("  tuck diff") + chalk21.dim("  - Preview what changed"));
     } else if (gitStatus.ahead > 0) {
-      console.log(chalk20.cyan("  tuck push") + chalk20.dim("  - Push commits to GitHub"));
+      console.log(chalk21.cyan("  tuck push") + chalk21.dim("  - Push commits to GitHub"));
     } else {
-      console.log(chalk20.dim("  All synced! Your dotfiles are up to date."));
+      console.log(chalk21.dim("  All synced! Your dotfiles are up to date."));
       console.log();
-      console.log(chalk20.cyan("  tuck scan") + chalk20.dim("  - Find more dotfiles to track"));
-      console.log(chalk20.cyan("  tuck list") + chalk20.dim("  - See tracked files"));
+      console.log(chalk21.cyan("  tuck scan") + chalk21.dim("  - Find more dotfiles to track"));
+      console.log(chalk21.cyan("  tuck list") + chalk21.dim("  - See tracked files"));
     }
     console.log();
   } catch {
     miniBanner();
-    console.log(chalk20.yellow("Tuck directory exists but may be corrupted."));
-    console.log(chalk20.dim("Run `tuck init` to reinitialize."));
+    console.log(chalk21.yellow("Tuck directory exists but may be corrupted."));
+    console.log(chalk21.dim("Run `tuck init` to reinitialize."));
     console.log();
   }
 };