@lumy-pack/syncpoint 0.0.1 → 0.0.2

package/dist/cli.mjs

@@ -3,11 +3,36 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/commands/Init.tsx
-import { useState, useEffect } from "react";
-import { Text, Box, useApp } from "ink";
+// src/commands/Backup.tsx
+import { Box, Text as Text2, useApp } from "ink";
 import { render } from "ink";
-import { join as join5 } from "path";
+import { useEffect, useState } from "react";
+
+// src/components/ProgressBar.tsx
+import { Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ProgressBar = ({
+  percent,
+  width = 30
+}) => {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(width * (clamped / 100));
+  const empty = width - filled;
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      clamped,
+      "%"
+    ] })
+  ] });
+};
+
+// src/core/backup.ts
+import { readdir } from "fs/promises";
+import { basename, join as join5 } from "path";
+import fg from "fast-glob";
 
 // src/constants.ts
 import { join as join2 } from "path";
@@ -55,6 +80,14 @@ async function fileExists(filePath) {
     return false;
   }
 }
+async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
 function isInsideDir(filePath, dir) {
   const resolvedFile = resolve(filePath);
   const resolvedDir = resolve(dir);
@@ -75,268 +108,12 @@ var LOGS_DIR = "logs";
 function getAppDir() {
   return join2(getHomeDir(), APP_DIR);
 }
-var APP_VERSION = "0.0.1";
 function getSubDir(sub) {
   return join2(getAppDir(), sub);
 }
 
-// src/utils/assets.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join as join3 } from "path";
-import { fileURLToPath } from "url";
-function getPackageRoot() {
-  let dir = dirname(fileURLToPath(import.meta.url));
-  while (dir !== dirname(dir)) {
-    if (existsSync(join3(dir, "package.json"))) return dir;
-    dir = dirname(dir);
-  }
-  throw new Error("Could not find package root");
-}
-function getAssetPath(filename) {
-  return join3(getPackageRoot(), "assets", filename);
-}
-function readAsset(filename) {
-  return readFileSync(getAssetPath(filename), "utf-8");
-}
-
-// src/core/config.ts
-import { readFile, writeFile } from "fs/promises";
-import { join as join4 } from "path";
-import YAML from "yaml";
-
-// src/schemas/ajv.ts
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-var ajv = new Ajv({ allErrors: true });
-addFormats(ajv);
-
-// src/schemas/config.schema.ts
-var configSchema = {
-  type: "object",
-  required: ["backup"],
-  properties: {
-    backup: {
-      type: "object",
-      required: ["targets", "exclude", "filename"],
-      properties: {
-        targets: {
-          type: "array",
-          items: { type: "string" }
-        },
-        exclude: {
-          type: "array",
-          items: { type: "string" }
-        },
-        filename: {
-          type: "string",
-          minLength: 1
-        },
-        destination: {
-          type: "string"
-        }
-      },
-      additionalProperties: false
-    },
-    scripts: {
-      type: "object",
-      properties: {
-        includeInBackup: {
-          type: "boolean"
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false
-};
-var validate = ajv.compile(configSchema);
-function validateConfig(data) {
-  const valid = validate(data);
-  if (valid) return { valid: true };
-  const errors = validate.errors?.map(
-    (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
-  );
-  return { valid: false, errors };
-}
-
-// src/core/config.ts
-function stripDangerousKeys(obj) {
-  if (obj === null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(stripDangerousKeys);
-  const cleaned = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (["__proto__", "constructor", "prototype"].includes(key)) continue;
-    cleaned[key] = stripDangerousKeys(value);
-  }
-  return cleaned;
-}
-function getConfigPath() {
-  return join4(getAppDir(), CONFIG_FILENAME);
-}
-async function loadConfig() {
-  const configPath = getConfigPath();
-  const exists = await fileExists(configPath);
-  if (!exists) {
-    throw new Error(
-      `Config file not found: ${configPath}
-Run "syncpoint init" first.`
-    );
-  }
-  const raw = await readFile(configPath, "utf-8");
-  const data = stripDangerousKeys(YAML.parse(raw));
-  const result = validateConfig(data);
-  if (!result.valid) {
-    throw new Error(
-      `Invalid config:
-${(result.errors ?? []).join("\n")}`
-    );
-  }
-  return data;
-}
-async function initDefaultConfig() {
-  const created = [];
-  const skipped = [];
-  const dirs = [
-    getAppDir(),
-    getSubDir(BACKUPS_DIR),
-    getSubDir(TEMPLATES_DIR),
-    getSubDir(SCRIPTS_DIR),
-    getSubDir(LOGS_DIR)
-  ];
-  for (const dir of dirs) {
-    const exists = await fileExists(dir);
-    if (!exists) {
-      await ensureDir(dir);
-      created.push(dir);
-    } else {
-      skipped.push(dir);
-    }
-  }
-  const configPath = getConfigPath();
-  const configExists = await fileExists(configPath);
-  if (!configExists) {
-    const yamlContent = readAsset("config.default.yml");
-    await writeFile(configPath, yamlContent, "utf-8");
-    created.push(configPath);
-  } else {
-    skipped.push(configPath);
-  }
-  return { created, skipped };
-}
-
-// src/commands/Init.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var InitView = () => {
-  const { exit } = useApp();
-  const [steps, setSteps] = useState([]);
-  const [error, setError] = useState(null);
-  const [complete, setComplete] = useState(false);
-  useEffect(() => {
-    (async () => {
-      try {
-        const appDir = getAppDir();
-        if (await fileExists(join5(appDir, CONFIG_FILENAME))) {
-          setError(`Already initialized: ${appDir}`);
-          exit();
-          return;
-        }
-        const dirs = [
-          { name: appDir, label: `~/.${APP_NAME}/` },
-          {
-            name: getSubDir(BACKUPS_DIR),
-            label: `~/.${APP_NAME}/${BACKUPS_DIR}/`
-          },
-          {
-            name: getSubDir(TEMPLATES_DIR),
-            label: `~/.${APP_NAME}/${TEMPLATES_DIR}/`
-          },
-          {
-            name: getSubDir(SCRIPTS_DIR),
-            label: `~/.${APP_NAME}/${SCRIPTS_DIR}/`
-          },
-          {
-            name: getSubDir(LOGS_DIR),
-            label: `~/.${APP_NAME}/${LOGS_DIR}/`
-          }
-        ];
-        const completed = [];
-        for (const dir of dirs) {
-          await ensureDir(dir.name);
-          completed.push({ name: `Created ${dir.label}`, done: true });
-          setSteps([...completed]);
-        }
-        await initDefaultConfig();
-        completed.push({ name: `Created ${CONFIG_FILENAME} (defaults)`, done: true });
-        setSteps([...completed]);
-        const exampleTemplatePath = join5(getSubDir(TEMPLATES_DIR), "example.yml");
-        if (!await fileExists(exampleTemplatePath)) {
-          const { writeFile: writeFile3 } = await import("fs/promises");
-          const exampleYaml = readAsset("template.example.yml");
-          await writeFile3(exampleTemplatePath, exampleYaml, "utf-8");
-          completed.push({ name: `Created templates/example.yml`, done: true });
-          setSteps([...completed]);
-        }
-        setComplete(true);
-        setTimeout(() => exit(), 100);
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        exit();
-      }
-    })();
-  }, []);
-  if (error) {
-    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
-      "\u2717 ",
-      error
-    ] }) });
-  }
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    steps.map((step, idx) => /* @__PURE__ */ jsxs(Text, { children: [
-      /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2713" }),
-      " ",
-      step.name
-    ] }, idx)),
-    complete && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx(Text, { bold: true, children: "Initialization complete! Next steps:" }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        "  ",
-        "1. Edit config.yml to specify backup targets"
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        "     ",
-        "\u2192 ~/.",
-        APP_NAME,
-        "/",
-        CONFIG_FILENAME
-      ] }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        "  ",
-        "2. Run ",
-        APP_NAME,
-        " backup to create your first snapshot"
-      ] })
-    ] })
-  ] });
-};
-function registerInitCommand(program2) {
-  program2.command("init").description(`Initialize ~/.${APP_NAME}/ directory structure and default config`).action(async () => {
-    const { waitUntilExit } = render(/* @__PURE__ */ jsx(InitView, {}));
-    await waitUntilExit();
-  });
-}
-
-// src/commands/Backup.tsx
-import { useState as useState2, useEffect as useEffect2 } from "react";
-import { Text as Text3, Box as Box2, useApp as useApp2 } from "ink";
-import { render as render2 } from "ink";
-
-// src/core/backup.ts
-import { readdir } from "fs/promises";
-import { join as join8, basename } from "path";
-import fg from "fast-glob";
-
 // src/utils/system.ts
-import { hostname as osHostname, platform, release, arch } from "os";
+import { arch, hostname as osHostname, platform, release } from "os";
 function getHostname() {
   return osHostname();
 }
@@ -349,7 +126,7 @@ function getSystemInfo() {
 }
 function formatHostname(name) {
   const raw = name ?? getHostname();
-  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9\-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return raw.replace(/\s+/g, "-").replace(/\./g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 
 // src/utils/format.ts
@@ -414,7 +191,7 @@ function generateFilename(pattern, options) {
 
 // src/utils/logger.ts
 import { appendFile, mkdir as mkdir2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join3 } from "path";
 import pc from "picocolors";
 var ANSI_RE = /\x1b\[[0-9;]*m/g;
 function stripAnsi(str) {
@@ -437,12 +214,12 @@ function dateStamp() {
 var logDirCreated = false;
 async function writeToFile(level, message) {
   try {
-    const logsDir = join6(getAppDir(), LOGS_DIR);
+    const logsDir = join3(getAppDir(), LOGS_DIR);
     if (!logDirCreated) {
       await mkdir2(logsDir, { recursive: true });
       logDirCreated = true;
     }
-    const logFile = join6(logsDir, `${dateStamp()}.log`);
+    const logFile = join3(logsDir, `${dateStamp()}.log`);
     const line = `[${timestamp()}] [${level.toUpperCase()}] ${stripAnsi(message)}
 `;
     await appendFile(logFile, line, "utf-8");
@@ -468,12 +245,114 @@ var logger = {
   }
 };
 
-// src/core/metadata.ts
-import { createHash } from "crypto";
-import { readFile as readFile2, lstat } from "fs/promises";
-
-// src/schemas/metadata.schema.ts
-var metadataSchema = {
+// src/utils/pattern.ts
+import micromatch from "micromatch";
+function detectPatternType(pattern) {
+  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 2) {
+    const inner = pattern.slice(1, -1);
+    const hasUnescapedSlash = /(?<!\\)\//.test(inner);
+    if (!hasUnescapedSlash) {
+      return "regex";
+    }
+  }
+  if (pattern.includes("*") || pattern.includes("?") || pattern.includes("{")) {
+    return "glob";
+  }
+  return "literal";
+}
+function parseRegexPattern(pattern) {
+  if (!pattern.startsWith("/") || !pattern.endsWith("/")) {
+    throw new Error(
+      `Invalid regex pattern format: ${pattern}. Must be enclosed in slashes like /pattern/`
+    );
+  }
+  const regexBody = pattern.slice(1, -1);
+  try {
+    return new RegExp(regexBody);
+  } catch (error) {
+    throw new Error(
+      `Invalid regex pattern: ${pattern}. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function createExcludeMatcher(excludePatterns) {
+  if (excludePatterns.length === 0) {
+    return () => false;
+  }
+  const regexPatterns = [];
+  const globPatterns = [];
+  const literalPatterns = /* @__PURE__ */ new Set();
+  for (const pattern of excludePatterns) {
+    const type = detectPatternType(pattern);
+    if (type === "regex") {
+      try {
+        regexPatterns.push(parseRegexPattern(pattern));
+      } catch {
+        console.warn(`Skipping invalid regex pattern: ${pattern}`);
+      }
+    } else if (type === "glob") {
+      globPatterns.push(pattern);
+    } else {
+      literalPatterns.add(pattern);
+    }
+  }
+  return (filePath) => {
+    if (literalPatterns.has(filePath)) {
+      return true;
+    }
+    if (globPatterns.length > 0 && micromatch.isMatch(filePath, globPatterns, {
+      dot: true,
+      // Match dotfiles
+      matchBase: false
+      // Don't use basename matching, match full path
+    })) {
+      return true;
+    }
+    for (const regex of regexPatterns) {
+      if (regex.test(filePath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function isValidPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return false;
+  }
+  const type = detectPatternType(pattern);
+  if (type === "regex") {
+    try {
+      parseRegexPattern(pattern);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/core/metadata.ts
+import { createHash } from "crypto";
+import { lstat, readFile } from "fs/promises";
+
+// src/schemas/ajv.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var ajv = new Ajv({ allErrors: true });
+addFormats(ajv);
+ajv.addKeyword({
+  keyword: "validPattern",
+  type: "string",
+  validate: function validate(schema, data) {
+    if (!schema) return true;
+    return isValidPattern(data);
+  },
+  errors: true
+});
+
+// src/schemas/metadata.schema.ts
+var metadataSchema = {
   type: "object",
   required: [
     "version",
@@ -546,13 +425,16 @@ function validateMetadata(data) {
   return { valid: false, errors };
 }
 
+// src/version.ts
+var VERSION = "0.0.2";
+
 // src/core/metadata.ts
 var METADATA_VERSION = "1.0.0";
 function createMetadata(files, config) {
   const totalSize = files.reduce((sum, f) => sum + f.size, 0);
   return {
     version: METADATA_VERSION,
-    toolVersion: APP_VERSION,
+    toolVersion: VERSION,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     hostname: getHostname(),
     system: getSystemInfo(),
@@ -572,15 +454,13 @@ function parseMetadata(data) {
   const parsed = JSON.parse(str);
   const result = validateMetadata(parsed);
   if (!result.valid) {
-    throw new Error(
-      `Invalid metadata:
-${(result.errors ?? []).join("\n")}`
-    );
+    throw new Error(`Invalid metadata:
+${(result.errors ?? []).join("\n")}`);
   }
   return parsed;
 }
 async function computeFileHash(filePath) {
-  const content = await readFile2(filePath);
+  const content = await readFile(filePath);
   const hash = createHash("sha256").update(content).digest("hex");
   return `sha256:${hash}`;
 }
@@ -591,6 +471,9 @@ async function collectFileInfo(absolutePath, logicalPath) {
     type = "symlink";
   } else if (lstats.isDirectory()) {
     type = "directory";
+    throw new Error(
+      `Cannot collect file info for directory: ${logicalPath}. Directories should be converted to glob patterns before calling collectFileInfo().`
+    );
   }
   let hash;
   if (lstats.isSymbolicLink()) {
@@ -608,25 +491,28 @@ async function collectFileInfo(absolutePath, logicalPath) {
 }
 
 // src/core/storage.ts
-import { mkdir as mkdir3, mkdtemp, readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, mkdtemp, readFile as readFile2, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join7, normalize as normalize2 } from "path";
+import { join as join4, normalize as normalize2 } from "path";
 import * as tar from "tar";
 async function createArchive(files, outputPath) {
-  const tmpDir = await mkdtemp(join7(tmpdir(), "syncpoint-"));
+  const tmpDir = await mkdtemp(join4(tmpdir(), "syncpoint-"));
   try {
     const fileNames = [];
     for (const file of files) {
-      const targetPath = join7(tmpDir, file.name);
-      const parentDir = join7(tmpDir, file.name.split("/").slice(0, -1).join("/"));
+      const targetPath = join4(tmpDir, file.name);
+      const parentDir = join4(
+        tmpDir,
+        file.name.split("/").slice(0, -1).join("/")
+      );
       if (parentDir !== tmpDir) {
         await mkdir3(parentDir, { recursive: true });
       }
       if (file.content !== void 0) {
-        await writeFile2(targetPath, file.content);
+        await writeFile(targetPath, file.content);
       } else if (file.sourcePath) {
-        const data = await readFile3(file.sourcePath);
-        await writeFile2(targetPath, data);
+        const data = await readFile2(file.sourcePath);
+        await writeFile(targetPath, data);
       }
       fileNames.push(file.name);
     }
@@ -661,7 +547,7 @@ async function readFileFromArchive(archivePath, filename) {
   if (filename.includes("..") || filename.startsWith("/")) {
     throw new Error(`Invalid filename: ${filename}`);
   }
-  const tmpDir = await mkdtemp(join7(tmpdir(), "syncpoint-read-"));
+  const tmpDir = await mkdtemp(join4(tmpdir(), "syncpoint-read-"));
   try {
     await tar.extract({
       file: archivePath,
@@ -671,9 +557,9 @@ async function readFileFromArchive(archivePath, filename) {
         return normalized === filename;
       }
     });
-    const extractedPath = join7(tmpDir, filename);
+    const extractedPath = join4(tmpDir, filename);
     try {
-      return await readFile3(extractedPath);
+      return await readFile2(extractedPath);
     } catch {
       return null;
     }
@@ -695,18 +581,48 @@ function isSensitiveFile(filePath) {
 async function scanTargets(config) {
   const found = [];
   const missing = [];
+  const isExcluded = createExcludeMatcher(config.backup.exclude);
   for (const target of config.backup.targets) {
     const expanded = expandTilde(target);
-    if (expanded.includes("*") || expanded.includes("?") || expanded.includes("{")) {
+    const patternType = detectPatternType(expanded);
+    if (patternType === "regex") {
+      try {
+        const regex = parseRegexPattern(expanded);
+        const homeDir = expandTilde("~/");
+        const homeDirNormalized = homeDir.endsWith("/") ? homeDir : `${homeDir}/`;
+        const allFiles = await fg(`${homeDirNormalized}**`, {
+          dot: true,
+          absolute: true,
+          onlyFiles: true,
+          deep: 5
+          // Limit depth for performance
+        });
+        for (const match of allFiles) {
+          if (regex.test(match) && !isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+      } catch (error) {
+        logger.warn(
+          `Invalid regex pattern "${target}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else if (patternType === "glob") {
+      const globExcludes = config.backup.exclude.filter(
+        (p) => detectPatternType(p) === "glob"
+      );
       const matches = await fg(expanded, {
         dot: true,
         absolute: true,
-        ignore: config.backup.exclude,
+        ignore: globExcludes,
         onlyFiles: true
       });
       for (const match of matches) {
-        const entry = await collectFileInfo(match, match);
-        found.push(entry);
+        if (!isExcluded(match)) {
+          const entry = await collectFileInfo(match, match);
+          found.push(entry);
+        }
       }
     } else {
       const absPath = resolveTargetPath(target);
@@ -715,16 +631,43 @@ async function scanTargets(config) {
         missing.push(target);
         continue;
       }
-      const entry = await collectFileInfo(absPath, absPath);
-      if (entry.size > LARGE_FILE_THRESHOLD) {
-        logger.warn(
-          `Large file (>${Math.round(LARGE_FILE_THRESHOLD / 1024 / 1024)}MB): ${target}`
+      const isDir = await isDirectory(absPath);
+      if (isDir) {
+        const dirGlob = `${expanded}/**/*`;
+        const globExcludes = config.backup.exclude.filter(
+          (p) => detectPatternType(p) === "glob"
         );
+        const matches = await fg(dirGlob, {
+          dot: true,
+          absolute: true,
+          ignore: globExcludes,
+          onlyFiles: true
+          // Only include files, not subdirectories
+        });
+        for (const match of matches) {
+          if (!isExcluded(match)) {
+            const entry = await collectFileInfo(match, match);
+            found.push(entry);
+          }
+        }
+        if (matches.length === 0) {
+          logger.warn(`Directory is empty or fully excluded: ${target}`);
+        }
+      } else {
+        if (isExcluded(absPath)) {
+          continue;
+        }
+        const entry = await collectFileInfo(absPath, absPath);
+        if (entry.size > LARGE_FILE_THRESHOLD) {
+          logger.warn(
+            `Large file (>${Math.round(LARGE_FILE_THRESHOLD / 1024 / 1024)}MB): ${target}`
+          );
+        }
+        if (isSensitiveFile(absPath)) {
+          logger.warn(`Sensitive file detected: ${target}`);
+        }
+        found.push(entry);
       }
-      if (isSensitiveFile(absPath)) {
-        logger.warn(`Sensitive file detected: ${target}`);
-      }
-      found.push(entry);
     }
   }
   return { found, missing };
@@ -738,7 +681,7 @@ async function collectScripts() {
     const files = await readdir(scriptsDir, { withFileTypes: true });
     for (const file of files) {
       if (file.isFile() && file.name.endsWith(".sh")) {
-        const absPath = join8(scriptsDir, file.name);
+        const absPath = join5(scriptsDir, file.name);
         const entry = await collectFileInfo(absPath, absPath);
         entries.push(entry);
       }
@@ -750,8 +693,10 @@ async function collectScripts() {
 }
 async function createBackup(config, options = {}) {
   const { found, missing } = await scanTargets(config);
-  for (const m of missing) {
-    logger.warn(`File not found, skipping: ${m}`);
+  if (options.verbose && missing.length > 0) {
+    for (const m of missing) {
+      logger.warn(`File not found, skipping: ${m}`);
+    }
   }
   let allFiles = [...found];
   if (config.scripts.includeInBackup) {
@@ -768,7 +713,7 @@ async function createBackup(config, options = {}) {
   const archiveFilename = `${filename}.tar.gz`;
   const destDir = config.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
   await ensureDir(destDir);
-  const archivePath = join8(destDir, archiveFilename);
+  const archivePath = join5(destDir, archiveFilename);
   if (options.dryRun) {
     return { archivePath, metadata };
   }
@@ -788,386 +733,348 @@ async function createBackup(config, options = {}) {
   return { archivePath, metadata };
 }
 
-// src/components/ProgressBar.tsx
-import { Text as Text2 } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var ProgressBar = ({
-  percent,
-  width = 30
-}) => {
-  const clamped = Math.max(0, Math.min(100, percent));
-  const filled = Math.round(width * (clamped / 100));
-  const empty = width - filled;
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2588".repeat(filled) }),
-    /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "\u2591".repeat(empty) }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      clamped,
-      "%"
-    ] })
-  ] });
-};
+// src/core/config.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { join as join7 } from "path";
+import YAML from "yaml";
 
-// src/commands/Backup.tsx
-import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var BackupView = ({ options }) => {
-  const { exit } = useApp2();
-  const [phase, setPhase] = useState2("scanning");
-  const [, setConfig] = useState2(null);
-  const [foundFiles, setFoundFiles] = useState2([]);
-  const [missingFiles, setMissingFiles] = useState2([]);
-  const [progress, setProgress] = useState2(0);
-  const [result, setResult] = useState2(null);
-  const [error, setError] = useState2(null);
-  useEffect2(() => {
-    (async () => {
-      try {
-        const cfg = await loadConfig();
-        setConfig(cfg);
-        const { found, missing } = await scanTargets(cfg);
-        setFoundFiles(found);
-        setMissingFiles(missing);
-        if (options.dryRun) {
-          setPhase("done");
-          setTimeout(() => exit(), 100);
-          return;
+// src/schemas/config.schema.ts
+var configSchema = {
+  type: "object",
+  required: ["backup"],
+  properties: {
+    backup: {
+      type: "object",
+      required: ["targets", "exclude", "filename"],
+      properties: {
+        targets: {
+          type: "array",
+          items: { type: "string", validPattern: true }
+        },
+        exclude: {
+          type: "array",
+          items: { type: "string", validPattern: true }
+        },
+        filename: {
+          type: "string",
+          minLength: 1
+        },
+        destination: {
+          type: "string"
         }
-        setPhase("compressing");
-        const progressInterval = setInterval(() => {
-          setProgress((prev) => {
-            if (prev >= 90) return prev;
-            return prev + 10;
-          });
-        }, 100);
-        const backupResult = await createBackup(cfg, options);
-        clearInterval(progressInterval);
-        setProgress(100);
-        setResult(backupResult);
-        setPhase("done");
-        setTimeout(() => exit(), 100);
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        setPhase("error");
-        exit();
-      }
-    })();
-  }, []);
-  if (phase === "error" || error) {
-    return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
-      "\u2717 Backup failed: ",
-      error
-    ] }) });
-  }
-  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "\u25B8 Scanning backup targets..." }),
-    foundFiles.map((file, idx) => /* @__PURE__ */ jsxs3(Text3, { children: [
-      "  ",
-      /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2713" }),
-      " ",
-      contractTilde(file.absolutePath),
-      /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
-        "    ",
-        formatBytes(file.size).padStart(10)
-      ] })
-    ] }, idx)),
-    missingFiles.map((file, idx) => /* @__PURE__ */ jsxs3(Text3, { children: [
-      "  ",
-      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u26A0" }),
-      " ",
-      file,
-      /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
-        "    ",
-        "File not found, skipped"
-      ] })
-    ] }, idx)),
-    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "(dry-run) No actual backup was created" }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "Target files: ",
-        foundFiles.length,
-        " (",
-        formatBytes(foundFiles.reduce((sum, f) => sum + f.size, 0)),
-        ")"
-      ] })
-    ] }),
-    phase === "compressing" && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Text3, { children: "\u25B8 Compressing..." }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "  ",
-        /* @__PURE__ */ jsx3(ProgressBar, { percent: progress })
-      ] })
-    ] }),
-    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713 Backup complete" }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "  ",
-        "File: ",
-        result.metadata.config.filename
-      ] }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "  ",
-        "Size: ",
-        formatBytes(result.metadata.summary.totalSize),
-        " (",
-        result.metadata.summary.fileCount,
-        " files + metadata)"
-      ] }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "  ",
-        "Path: ",
-        contractTilde(result.archivePath)
-      ] })
-    ] })
-  ] });
+      },
+      additionalProperties: false
+    },
+    scripts: {
+      type: "object",
+      properties: {
+        includeInBackup: {
+          type: "boolean"
+        }
+      },
+      additionalProperties: false
+    }
+  },
+  additionalProperties: false
 };
-function registerBackupCommand(program2) {
-  program2.command("backup").description("Create a config file backup").option("--dry-run", "Show target file list without actual compression", false).option("--tag <name>", "Add a tag to the backup filename").action(async (opts) => {
-    const { waitUntilExit } = render2(
-      /* @__PURE__ */ jsx3(BackupView, { options: { dryRun: opts.dryRun, tag: opts.tag } })
-    );
-    await waitUntilExit();
-  });
+var validate3 = ajv.compile(configSchema);
+function validateConfig(data) {
+  const valid = validate3(data);
+  if (valid) return { valid: true };
+  const errors = validate3.errors?.map(
+    (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
+  );
+  return { valid: false, errors };
 }
 
-// src/commands/Restore.tsx
-import { useState as useState4, useEffect as useEffect3 } from "react";
-import { Text as Text5, Box as Box3, useApp as useApp3 } from "ink";
-import SelectInput from "ink-select-input";
-import { render as render3 } from "ink";
+// src/utils/assets.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join as join6 } from "path";
+import { fileURLToPath } from "url";
+function getPackageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  while (dir !== dirname(dir)) {
+    if (existsSync(join6(dir, "package.json"))) return dir;
+    dir = dirname(dir);
+  }
+  throw new Error("Could not find package root");
+}
+function getAssetPath(filename) {
+  return join6(getPackageRoot(), "assets", filename);
+}
+function readAsset(filename) {
+  return readFileSync(getAssetPath(filename), "utf-8");
+}
 
-// src/core/restore.ts
-import { copyFile, lstat as lstat2, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join9, dirname as dirname2 } from "path";
-async function getBackupList(config) {
-  const backupDir = config?.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
-  const exists = await fileExists(backupDir);
-  if (!exists) return [];
-  const entries = await readdir2(backupDir, { withFileTypes: true });
-  const backups = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".tar.gz")) continue;
-    const fullPath = join9(backupDir, entry.name);
-    const fileStat = await stat2(fullPath);
-    let hostname;
-    let fileCount;
-    try {
-      const metaBuf = await readFileFromArchive(fullPath, METADATA_FILENAME);
-      if (metaBuf) {
-        const meta = parseMetadata(metaBuf);
-        hostname = meta.hostname;
-        fileCount = meta.summary.fileCount;
-      }
-    } catch {
-      logger.info(`Could not read metadata from: ${entry.name}`);
-    }
-    backups.push({
-      filename: entry.name,
-      path: fullPath,
-      size: fileStat.size,
-      createdAt: fileStat.mtime,
-      hostname,
-      fileCount
-    });
+// src/core/config.ts
+function stripDangerousKeys(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(stripDangerousKeys);
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (["__proto__", "constructor", "prototype"].includes(key)) continue;
+    cleaned[key] = stripDangerousKeys(value);
   }
-  backups.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-  return backups;
+  return cleaned;
 }
-async function getRestorePlan(archivePath) {
-  const metaBuf = await readFileFromArchive(archivePath, METADATA_FILENAME);
-  if (!metaBuf) {
+function getConfigPath() {
+  return join7(getAppDir(), CONFIG_FILENAME);
+}
+async function loadConfig() {
+  const configPath = getConfigPath();
+  const exists = await fileExists(configPath);
+  if (!exists) {
     throw new Error(
-      `No metadata found in archive: ${archivePath}
-This may not be a valid syncpoint backup.`
+      `Config file not found: ${configPath}
+Run "syncpoint init" first.`
     );
   }
-  const metadata = parseMetadata(metaBuf);
-  const actions = [];
-  for (const file of metadata.files) {
-    const absPath = resolveTargetPath(file.path);
-    const exists = await fileExists(absPath);
+  const raw = await readFile3(configPath, "utf-8");
+  const data = stripDangerousKeys(YAML.parse(raw));
+  const result = validateConfig(data);
+  if (!result.valid) {
+    throw new Error(`Invalid config:
+${(result.errors ?? []).join("\n")}`);
+  }
+  return data;
+}
+async function initDefaultConfig() {
+  const created = [];
+  const skipped = [];
+  const dirs = [
+    getAppDir(),
+    getSubDir(BACKUPS_DIR),
+    getSubDir(TEMPLATES_DIR),
+    getSubDir(SCRIPTS_DIR),
+    getSubDir(LOGS_DIR)
+  ];
+  for (const dir of dirs) {
+    const exists = await fileExists(dir);
     if (!exists) {
-      actions.push({
-        path: file.path,
-        action: "create",
-        backupSize: file.size,
-        reason: "File does not exist on this machine"
-      });
-      continue;
-    }
-    const currentHash = await computeFileHash(absPath);
-    const currentStat = await stat2(absPath);
-    if (currentHash === file.hash) {
-      actions.push({
-        path: file.path,
-        action: "skip",
-        currentSize: currentStat.size,
-        backupSize: file.size,
-        reason: "File is identical (same hash)"
-      });
+      await ensureDir(dir);
+      created.push(dir);
     } else {
-      actions.push({
-        path: file.path,
-        action: "overwrite",
-        currentSize: currentStat.size,
-        backupSize: file.size,
-        reason: "File has been modified"
-      });
+      skipped.push(dir);
     }
   }
-  return { metadata, actions };
-}
-async function createSafetyBackup(filePaths) {
-  const now = /* @__PURE__ */ new Date();
-  const filename = `_pre-restore_${formatDatetime(now)}.tar.gz`;
-  const backupDir = getSubDir(BACKUPS_DIR);
-  await ensureDir(backupDir);
-  const archivePath = join9(backupDir, filename);
-  const files = [];
-  for (const fp of filePaths) {
-    const absPath = resolveTargetPath(fp);
-    const exists = await fileExists(absPath);
-    if (!exists) continue;
-    const archiveName = fp.startsWith("~/") ? fp.slice(2) : fp;
-    files.push({ name: archiveName, sourcePath: absPath });
-  }
-  if (files.length === 0) {
-    logger.info("No existing files to safety-backup.");
-    return archivePath;
+  const configPath = getConfigPath();
+  const configExists = await fileExists(configPath);
+  if (!configExists) {
+    const yamlContent = readAsset("config.default.yml");
+    await writeFile2(configPath, yamlContent, "utf-8");
+    created.push(configPath);
+  } else {
+    skipped.push(configPath);
   }
-  await createArchive(files, archivePath);
-  logger.info(`Safety backup created: ${archivePath}`);
-  return archivePath;
+  return { created, skipped };
 }
-async function restoreBackup(archivePath, options = {}) {
-  const plan = await getRestorePlan(archivePath);
-  const restoredFiles = [];
-  const skippedFiles = [];
-  const overwritePaths = plan.actions.filter((a) => a.action === "overwrite").map((a) => a.path);
-  let safetyBackupPath;
-  if (overwritePaths.length > 0 && !options.dryRun) {
-    safetyBackupPath = await createSafetyBackup(overwritePaths);
-  }
-  if (options.dryRun) {
-    return {
-      restoredFiles: plan.actions.filter((a) => a.action !== "skip").map((a) => a.path),
-      skippedFiles: plan.actions.filter((a) => a.action === "skip").map((a) => a.path),
-      safetyBackupPath
-    };
-  }
-  const { mkdtemp: mkdtemp2, rm: rm2 } = await import("fs/promises");
-  const { tmpdir: tmpdir2 } = await import("os");
-  const tmpDir = await mkdtemp2(join9(tmpdir2(), "syncpoint-restore-"));
-  try {
-    await extractArchive(archivePath, tmpDir);
-    for (const action of plan.actions) {
-      if (action.action === "skip") {
-        skippedFiles.push(action.path);
-        continue;
+
+// src/utils/command-registry.ts
+var COMMANDS = {
+  init: {
+    name: "init",
+    description: "Initialize ~/.syncpoint/ directory structure and default config",
+    usage: "npx @lumy-pack/syncpoint init",
+    examples: ["npx @lumy-pack/syncpoint init"]
+  },
+  wizard: {
+    name: "wizard",
+    description: "Interactive wizard to generate config.yml with AI",
+    usage: "npx @lumy-pack/syncpoint wizard [options]",
+    options: [
+      {
+        flag: "-p, --print",
+        description: "Print prompt instead of invoking Claude Code"
       }
-      const archiveName = action.path.startsWith("~/") ? action.path.slice(2) : action.path;
-      const extractedPath = join9(tmpDir, archiveName);
-      const destPath = resolveTargetPath(action.path);
-      const extractedExists = await fileExists(extractedPath);
-      if (!extractedExists) {
-        logger.warn(`File not found in archive: ${archiveName}`);
-        skippedFiles.push(action.path);
-        continue;
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint wizard",
+      "npx @lumy-pack/syncpoint wizard --print"
+    ]
+  },
+  backup: {
+    name: "backup",
+    description: "Create a compressed backup archive of your configuration files",
+    usage: "npx @lumy-pack/syncpoint backup [options]",
+    options: [
+      {
+        flag: "--dry-run",
+        description: "Preview files to be backed up without creating archive"
+      },
+      {
+        flag: "--tag <name>",
+        description: "Add custom tag to backup filename"
+      },
+      {
+        flag: "-v, --verbose",
+        description: "Show detailed output including missing files"
       }
-      await ensureDir(dirname2(destPath));
-      try {
-        const destStat = await lstat2(destPath);
-        if (destStat.isSymbolicLink()) {
-          logger.warn(`Skipping symlink target: ${action.path}`);
-          skippedFiles.push(action.path);
-          continue;
-        }
-      } catch (err) {
-        if (err.code !== "ENOENT") throw err;
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint backup",
+      "npx @lumy-pack/syncpoint backup --dry-run",
+      'npx @lumy-pack/syncpoint backup --tag "before-upgrade"'
+    ]
+  },
+  restore: {
+    name: "restore",
+    description: "Restore configuration files from a backup archive",
+    usage: "npx @lumy-pack/syncpoint restore [filename] [options]",
+    arguments: [
+      {
+        name: "filename",
+        description: "Backup file to restore (optional, interactive if omitted)",
+        required: false
       }
-      await copyFile(extractedPath, destPath);
-      restoredFiles.push(action.path);
-    }
-  } finally {
-    await rm2(tmpDir, { recursive: true, force: true });
+    ],
+    options: [
+      {
+        flag: "--dry-run",
+        description: "Show restore plan without actually restoring"
+      }
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint restore",
+      "npx @lumy-pack/syncpoint restore macbook-pro_2024-01-15.tar.gz",
+      "npx @lumy-pack/syncpoint restore --dry-run"
+    ]
+  },
+  provision: {
+    name: "provision",
+    description: "Run template-based machine provisioning",
+    usage: "npx @lumy-pack/syncpoint provision <template> [options]",
+    arguments: [
+      {
+        name: "template",
+        description: "Template name to execute",
+        required: true
+      }
+    ],
+    options: [
+      {
+        flag: "--dry-run",
+        description: "Show execution plan without running commands"
+      },
+      {
+        flag: "--skip-restore",
+        description: "Skip automatic config restore after provisioning"
+      }
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint provision dev-setup",
+      "npx @lumy-pack/syncpoint provision dev-setup --dry-run",
+      "npx @lumy-pack/syncpoint provision dev-setup --skip-restore"
+    ]
+  },
+  "create-template": {
+    name: "create-template",
+    description: "Interactive wizard to create a provisioning template with AI",
+    usage: "npx @lumy-pack/syncpoint create-template [name] [options]",
+    arguments: [
+      {
+        name: "name",
+        description: "Template filename (optional, generated from template name if omitted)",
+        required: false
+      }
+    ],
+    options: [
+      {
+        flag: "-p, --print",
+        description: "Print prompt instead of invoking Claude Code"
+      }
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint create-template",
+      "npx @lumy-pack/syncpoint create-template my-dev-setup",
+      "npx @lumy-pack/syncpoint create-template --print"
+    ]
+  },
+  list: {
+    name: "list",
+    description: "Browse and manage backups and templates interactively",
+    usage: "npx @lumy-pack/syncpoint list [type] [options]",
+    arguments: [
+      {
+        name: "type",
+        description: 'Filter by type: "backups" or "templates" (optional)',
+        required: false
+      }
+    ],
+    options: [{ flag: "--delete <n>", description: "Delete item number n" }],
+    examples: [
+      "npx @lumy-pack/syncpoint list",
+      "npx @lumy-pack/syncpoint list backups",
+      "npx @lumy-pack/syncpoint list templates"
+    ]
+  },
+  status: {
+    name: "status",
+    description: "Show ~/.syncpoint/ status summary and manage cleanup",
+    usage: "npx @lumy-pack/syncpoint status [options]",
+    options: [
+      { flag: "--cleanup", description: "Enter interactive cleanup mode" }
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint status",
+      "npx @lumy-pack/syncpoint status --cleanup"
+    ]
+  },
+  help: {
+    name: "help",
+    description: "Display help information",
+    usage: "npx @lumy-pack/syncpoint help [command]",
+    arguments: [
+      {
+        name: "command",
+        description: "Command to get detailed help for (optional)",
+        required: false
+      }
+    ],
+    examples: [
+      "npx @lumy-pack/syncpoint help",
+      "npx @lumy-pack/syncpoint help backup",
+      "npx @lumy-pack/syncpoint help provision"
+    ]
   }
-  return { restoredFiles, skippedFiles, safetyBackupPath };
-}
-
-// src/components/Confirm.tsx
-import { Text as Text4, useInput } from "ink";
-import { useState as useState3 } from "react";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-var Confirm = ({
-  message,
-  onConfirm,
-  defaultYes = true
-}) => {
-  const [answered, setAnswered] = useState3(false);
-  useInput((input, key) => {
-    if (answered) return;
-    if (input === "y" || input === "Y") {
-      setAnswered(true);
-      onConfirm(true);
-    } else if (input === "n" || input === "N") {
-      setAnswered(true);
-      onConfirm(false);
-    } else if (key.return) {
-      setAnswered(true);
-      onConfirm(defaultYes);
-    }
-  });
-  const yText = defaultYes ? /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Y" }) : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "y" });
-  const nText = defaultYes ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "n" }) : /* @__PURE__ */ jsx4(Text4, { bold: true, children: "N" });
-  return /* @__PURE__ */ jsxs4(Text4, { children: [
-    /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "? " }),
-    message,
-    " ",
-    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "[" }),
-    yText,
-    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "/" }),
-    nText,
-    /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "]" })
-  ] });
 };
 
-// src/commands/Restore.tsx
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-var RestoreView = ({ filename, options }) => {
-  const { exit } = useApp3();
-  const [phase, setPhase] = useState4("loading");
-  const [backups, setBackups] = useState4([]);
-  const [selectedPath, setSelectedPath] = useState4(null);
-  const [plan, setPlan] = useState4(null);
-  const [result, setResult] = useState4(null);
-  const [safetyDone, setSafetyDone] = useState4(false);
-  const [error, setError] = useState4(null);
-  useEffect3(() => {
+// src/commands/Backup.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var BackupView = ({ options }) => {
+  const { exit } = useApp();
+  const [phase, setPhase] = useState("scanning");
+  const [, setConfig] = useState(null);
+  const [foundFiles, setFoundFiles] = useState([]);
+  const [missingFiles, setMissingFiles] = useState([]);
+  const [progress, setProgress] = useState(0);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
     (async () => {
       try {
-        const list2 = await getBackupList();
-        setBackups(list2);
-        if (list2.length === 0) {
-          setError("No backups available.");
-          setPhase("error");
-          exit();
+        const cfg = await loadConfig();
+        setConfig(cfg);
+        const { found, missing } = await scanTargets(cfg);
+        setFoundFiles(found);
+        setMissingFiles(missing);
+        if (options.dryRun) {
+          setPhase("done");
+          setTimeout(() => exit(), 100);
           return;
         }
-        if (filename) {
-          const match = list2.find(
-            (b) => b.filename === filename || b.filename.startsWith(filename)
-          );
-          if (!match) {
-            setError(`Backup not found: ${filename}`);
-            setPhase("error");
-            exit();
-            return;
-          }
-          setSelectedPath(match.path);
-          setPhase("planning");
-        } else {
-          setPhase("selecting");
-        }
+        setPhase("compressing");
+        const progressInterval = setInterval(() => {
+          setProgress((prev) => {
+            if (prev >= 90) return prev;
+            return prev + 10;
+          });
+        }, 100);
+        const backupResult = await createBackup(cfg, options);
+        clearInterval(progressInterval);
+        setProgress(100);
+        setResult(backupResult);
+        setPhase("done");
+        setTimeout(() => exit(), 100);
       } catch (err) {
         setError(err instanceof Error ? err.message : String(err));
         setPhase("error");
@@ -1175,197 +1082,95 @@ var RestoreView = ({ filename, options }) => {
       }
     })();
   }, []);
-  useEffect3(() => {
-    if (phase !== "planning" || !selectedPath) return;
-    (async () => {
-      try {
-        const restorePlan = await getRestorePlan(selectedPath);
-        setPlan(restorePlan);
-        if (options.dryRun) {
-          setPhase("done");
-          setTimeout(() => exit(), 100);
-        } else {
-          setPhase("confirming");
-        }
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-        setPhase("error");
-        exit();
-      }
-    })();
-  }, [phase, selectedPath]);
-  const handleSelect = (item) => {
-    setSelectedPath(item.value);
-    setPhase("planning");
-  };
-  const handleConfirm = async (yes) => {
-    if (!yes || !selectedPath) {
-      setPhase("done");
-      setTimeout(() => exit(), 100);
-      return;
-    }
-    try {
-      setPhase("restoring");
-      try {
-        const config = await loadConfig();
-        await createBackup(config, { tag: "pre-restore" });
-        setSafetyDone(true);
-      } catch {
-      }
-      const restoreResult = await restoreBackup(selectedPath, options);
-      setResult(restoreResult);
-      setPhase("done");
-      setTimeout(() => exit(), 100);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-      setPhase("error");
-      exit();
-    }
-  };
   if (phase === "error" || error) {
-    return /* @__PURE__ */ jsx5(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
-      "\u2717 ",
+    return /* @__PURE__ */ jsx2(Box, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+      "\u2717 Backup failed: ",
       error
     ] }) });
   }
-  const selectItems = backups.map((b, idx) => ({
-    label: `${String(idx + 1).padStart(2)}  ${b.filename.replace(".tar.gz", "").padEnd(40)}  ${formatBytes(b.size).padStart(8)}   ${formatDate(b.createdAt)}`,
-    value: b.path
-  }));
-  const currentHostname = getHostname();
-  const isRemoteBackup = plan?.metadata.hostname && plan.metadata.hostname !== currentHostname;
-  return /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
-    phase === "loading" && /* @__PURE__ */ jsx5(Text5, { children: "\u25B8 Loading backup list..." }),
-    phase === "selecting" && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "\u25B8 Select backup" }),
-      /* @__PURE__ */ jsx5(SelectInput, { items: selectItems, onSelect: handleSelect })
-    ] }),
-    (phase === "planning" || phase === "confirming" || phase === "restoring" || phase === "done" && plan) && plan && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginBottom: 1, children: [
-        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
-          "\u25B8 Metadata (",
-          plan.metadata.config.filename ?? "",
-          ")"
-        ] }),
-        /* @__PURE__ */ jsxs5(Text5, { children: [
-          "  ",
-          "Host: ",
-          plan.metadata.hostname
-        ] }),
-        /* @__PURE__ */ jsxs5(Text5, { children: [
-          "  ",
-          "Created: ",
-          plan.metadata.createdAt
-        ] }),
-        /* @__PURE__ */ jsxs5(Text5, { children: [
-          "  ",
-          "Files: ",
-          plan.metadata.summary.fileCount,
-          " (",
-          formatBytes(plan.metadata.summary.totalSize),
-          ")"
-        ] }),
-        isRemoteBackup && /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
-          "  ",
-          "\u26A0 This backup was created on a different machine (",
-          plan.metadata.hostname,
-          ")"
-        ] })
-      ] }),
-      /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginBottom: 1, children: [
-        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "\u25B8 Restore plan:" }),
-        plan.actions.map((action, idx) => {
-          let icon;
-          let color;
-          let label;
-          switch (action.action) {
-            case "overwrite":
-              icon = "Overwrite";
-              color = "yellow";
-              label = `(${formatBytes(action.currentSize ?? 0)} \u2192 ${formatBytes(action.backupSize ?? 0)}, ${action.reason})`;
-              break;
-            case "skip":
-              icon = "Skip";
-              color = "gray";
-              label = `(${action.reason})`;
-              break;
-            case "create":
-              icon = "Create";
-              color = "green";
-              label = "(not present)";
-              break;
-          }
-          return /* @__PURE__ */ jsxs5(Text5, { children: [
-            "  ",
-            /* @__PURE__ */ jsx5(Text5, { color, children: icon.padEnd(8) }),
-            "  ",
-            contractTilde(action.path),
-            "  ",
-            /* @__PURE__ */ jsx5(Text5, { color: "gray", children: label })
-          ] }, idx);
-        })
-      ] }),
-      options.dryRun && phase === "done" && /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "(dry-run) No actual restore was performed" })
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "\u25B8 Scanning backup targets..." }),
+    foundFiles.map((file, idx) => /* @__PURE__ */ jsxs2(Text2, { children: [
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" }),
+      " ",
+      contractTilde(file.absolutePath),
+      /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "    ",
+        formatBytes(file.size).padStart(10)
+      ] })
+    ] }, idx)),
+    missingFiles.map((file, idx) => /* @__PURE__ */ jsxs2(Text2, { children: [
+      "  ",
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u26A0" }),
+      " ",
+      file,
+      /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "    ",
+        "File not found, skipped"
+      ] })
+    ] }, idx)),
+    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "(dry-run) No actual backup was created" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Target files: ",
+        foundFiles.length,
+        " (",
+        formatBytes(foundFiles.reduce((sum, f) => sum + f.size, 0)),
+        ")"
+      ] })
     ] }),
-    phase === "confirming" && /* @__PURE__ */ jsx5(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx5(Confirm, { message: "Proceed with restore?", onConfirm: handleConfirm }) }),
-    phase === "restoring" && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", children: [
-      safetyDone && /* @__PURE__ */ jsxs5(Text5, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }),
-        " Safety backup of current files complete"
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { children: "\u25B8 Restoring..." })
+    phase === "compressing" && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { children: "\u25B8 Compressing..." }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "  ",
+        /* @__PURE__ */ jsx2(ProgressBar, { percent: progress })
+      ] })
     ] }),
-    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs5(Box3, { flexDirection: "column", marginTop: 1, children: [
-      safetyDone && /* @__PURE__ */ jsxs5(Text5, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }),
-        " Safety backup of current files complete"
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { color: "green", bold: true, children: "\u2713 Restore complete" }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
+    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "green", bold: true, children: "\u2713 Backup complete" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
         "  ",
-        "Restored: ",
-        result.restoredFiles.length,
-        " files"
+        "File: ",
+        result.metadata.config.filename
       ] }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { children: [
         "  ",
-        "Skipped: ",
-        result.skippedFiles.length,
-        " files"
+        "Size: ",
+        formatBytes(result.metadata.summary.totalSize),
+        " (",
+        result.metadata.summary.fileCount,
+        " files + metadata)"
       ] }),
-      result.safetyBackupPath && /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { children: [
         "  ",
-        "Safety backup: ",
-        contractTilde(result.safetyBackupPath)
+        "Path: ",
+        contractTilde(result.archivePath)
       ] })
     ] })
   ] });
 };
-function registerRestoreCommand(program2) {
-  program2.command("restore [filename]").description("Restore config files from a backup").option("--dry-run", "Show planned changes without actual restore", false).action(async (filename, opts) => {
-    const { waitUntilExit } = render3(
-      /* @__PURE__ */ jsx5(
-        RestoreView,
-        {
-          filename,
-          options: { dryRun: opts.dryRun }
-        }
-      )
+function registerBackupCommand(program2) {
+  const cmdInfo = COMMANDS.backup;
+  const cmd = program2.command("backup").description(cmdInfo.description);
+  cmdInfo.options?.forEach((opt) => {
+    cmd.option(opt.flag, opt.description);
+  });
+  cmd.action(async (opts) => {
+    const { waitUntilExit } = render(
+      /* @__PURE__ */ jsx2(BackupView, { options: { dryRun: opts.dryRun, tag: opts.tag, verbose: opts.verbose } })
     );
     await waitUntilExit();
   });
 }
 
-// src/commands/Provision.tsx
-import { useState as useState5, useEffect as useEffect4 } from "react";
-import { Text as Text7, Box as Box5, useApp as useApp4 } from "ink";
-import { render as render4 } from "ink";
-
-// src/core/provision.ts
-import { exec } from "child_process";
-import { readFile as readFile4, readdir as readdir3 } from "fs/promises";
-import { join as join10 } from "path";
-import YAML2 from "yaml";
+// src/commands/CreateTemplate.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Text as Text3, Box as Box2, useApp as useApp2 } from "ink";
+import Spinner from "ink-spinner";
+import { render as render2 } from "ink";
+import { join as join9 } from "path";
+import { writeFile as writeFile4 } from "fs/promises";
 
 // src/schemas/template.schema.ts
 var templateSchema = {
@@ -1395,168 +1200,1414 @@ var templateSchema = {
   },
   additionalProperties: false
 };
-var validate3 = ajv.compile(templateSchema);
+var validate4 = ajv.compile(templateSchema);
 function validateTemplate(data) {
-  const valid = validate3(data);
+  const valid = validate4(data);
   if (valid) return { valid: true };
-  const errors = validate3.errors?.map(
+  const errors = validate4.errors?.map(
     (e) => `${e.instancePath || "/"} ${e.message ?? "unknown error"}`
   );
   return { valid: false, errors };
 }
 
-// src/core/provision.ts
-var REMOTE_SCRIPT_PATTERNS = [
-  /curl\s.*\|\s*(ba)?sh/,
-  /wget\s.*\|\s*(ba)?sh/,
-  /curl\s.*\|\s*python/,
-  /wget\s.*\|\s*python/
-];
-function containsRemoteScriptPattern(command) {
-  return REMOTE_SCRIPT_PATTERNS.some((p) => p.test(command));
+// src/prompts/wizard-template.ts
+function generateTemplateWizardPrompt(variables) {
+  return `You are a Syncpoint provisioning template assistant. Your role is to help users create automated environment setup templates.
+
+**Input:**
+1. User's provisioning requirements (described in natural language)
+2. Example template structure (YAML)
+
+**Your Task:**
+1. Ask clarifying questions to understand the provisioning workflow:
+   - What software/tools need to be installed?
+   - What dependencies should be checked?
+   - Are there any configuration steps after installation?
+   - Should any steps require sudo privileges?
+   - Should any steps be conditional (skip_if)?
+2. Based on user responses, generate a complete provision template
+
+**Output Requirements:**
+- Pure YAML format only (no markdown, no code blocks, no explanations)
+- Must be valid according to Syncpoint template schema
+- Required fields:
+  - \`name\`: Template name
+  - \`steps\`: Array of provisioning steps (minimum 1)
+- Each step must include:
+  - \`name\`: Step name (required)
+  - \`command\`: Shell command to execute (required)
+  - \`description\`: Step description (optional)
+  - \`skip_if\`: Condition to skip step (optional)
+  - \`continue_on_error\`: Whether to continue on failure (optional, default: false)
+- Optional template fields:
+  - \`description\`: Template description
+  - \`backup\`: Backup name to restore after provisioning
+  - \`sudo\`: Whether sudo is required (boolean)
+
+**Example Template:**
+${variables.exampleTemplate}
+
+Begin by asking the user to describe their provisioning needs.`;
 }
-function sanitizeErrorOutput(output) {
-  return output.replace(/\/Users\/[^\s/]+/g, "/Users/***").replace(/\/home\/[^\s/]+/g, "/home/***").replace(/(password|token|key|secret)[=:]\s*\S+/gi, "$1=***").slice(0, 500);
+
+// src/utils/claude-code-runner.ts
+import { spawn } from "child_process";
+import { unlink, writeFile as writeFile3 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join8 } from "path";
+async function isClaudeCodeAvailable() {
+  return new Promise((resolve2) => {
+    const child = spawn("which", ["claude"], { shell: true });
+    child.on("close", (code) => {
+      resolve2(code === 0);
+    });
+    child.on("error", () => {
+      resolve2(false);
+    });
+  });
 }
-async function loadTemplate(templatePath) {
-  const exists = await fileExists(templatePath);
-  if (!exists) {
-    throw new Error(`Template not found: ${templatePath}`);
-  }
-  const raw = await readFile4(templatePath, "utf-8");
-  const data = YAML2.parse(raw);
-  const result = validateTemplate(data);
-  if (!result.valid) {
-    throw new Error(
-      `Invalid template ${templatePath}:
-${(result.errors ?? []).join("\n")}`
-    );
+async function invokeClaudeCode(prompt, options) {
+  const timeout = options?.timeout ?? 12e4;
+  const promptFile = join8(tmpdir2(), `syncpoint-prompt-${Date.now()}.txt`);
+  await writeFile3(promptFile, prompt, "utf-8");
+  try {
+    return await new Promise((resolve2, reject) => {
+      const args = ["--permission-mode", "acceptEdits", "--model", "sonnet"];
+      if (options?.sessionId) {
+        args.push("--session", options.sessionId);
+      }
+      const child = spawn("claude", args, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error(`Claude Code invocation timeout after ${timeout}ms`));
+      }, timeout);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve2({
+            success: true,
+            output: stdout,
+            sessionId: options?.sessionId
+          });
+        } else {
+          resolve2({
+            success: false,
+            output: stdout,
+            error: stderr || `Process exited with code ${code}`
+          });
+        }
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  } finally {
+    try {
+      await unlink(promptFile);
+    } catch {
+    }
   }
-  return data;
 }
-async function listTemplates() {
-  const templatesDir = getSubDir(TEMPLATES_DIR);
-  const exists = await fileExists(templatesDir);
-  if (!exists) return [];
-  const entries = await readdir3(templatesDir, { withFileTypes: true });
-  const templates = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".yml") && !entry.name.endsWith(".yaml")) {
-      continue;
+async function resumeClaudeCodeSession(sessionId, prompt, options) {
+  return invokeClaudeCode(prompt, {
+    sessionId,
+    timeout: options?.timeout
+  });
+}
+async function invokeClaudeCodeInteractive(prompt) {
+  return await new Promise((resolve2, reject) => {
+    const initialMessage = `${prompt}
+
+IMPORTANT INSTRUCTIONS:
+1. After gathering the user's backup preferences through conversation
+2. Use the Write tool to create the file at: ~/.syncpoint/config.yml
+3. The file must be valid YAML following the Syncpoint schema
+4. Include backup.targets array with recommended files based on user responses
+5. Include backup.exclude array with common exclusions
+
+Start by asking the user about their backup priorities for the home directory structure provided above.`;
+    const args = [
+      "--permission-mode",
+      "acceptEdits",
+      "--model",
+      "sonnet",
+      initialMessage
+      // Include full context and instructions in initial message
+    ];
+    const child = spawn("claude", args, {
+      stdio: "inherit"
+      // Share stdin/stdout/stderr with parent process
+    });
+    child.on("close", (code) => {
+      resolve2({
+        success: code === 0,
+        output: ""
+        // No captured output in interactive mode
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+// src/utils/yaml-parser.ts
+import YAML2 from "yaml";
+function isStructuredYAML(parsed) {
+  return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+}
+function extractYAML(response) {
+  const codeBlockMatch = response.match(/```ya?ml\s*\n([\s\S]*?)\n```/);
+  if (codeBlockMatch) {
+    const content = codeBlockMatch[1].trim();
+    try {
+      const parsed = YAML2.parse(content);
+      if (isStructuredYAML(parsed)) return content;
+    } catch {
     }
-    const fullPath = join10(templatesDir, entry.name);
+  }
+  const genericCodeBlockMatch = response.match(/```\s*\n([\s\S]*?)\n```/);
+  if (genericCodeBlockMatch) {
+    const content = genericCodeBlockMatch[1].trim();
     try {
-      const config = await loadTemplate(fullPath);
-      templates.push({
-        name: entry.name.replace(/\.ya?ml$/, ""),
-        path: fullPath,
-        config
-      });
+      const parsed = YAML2.parse(content);
+      if (isStructuredYAML(parsed)) return content;
     } catch {
-      logger.warn(`Skipping invalid template: ${entry.name}`);
     }
   }
-  return templates;
+  try {
+    const parsed = YAML2.parse(response);
+    if (isStructuredYAML(parsed)) {
+      return response.trim();
+    }
+  } catch {
+  }
+  return null;
 }
-function execAsync(command) {
-  return new Promise((resolve2, reject) => {
-    exec(
-      command,
-      { shell: "/bin/bash", timeout: 3e5 },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(
-            Object.assign(error, {
-              stdout: stdout?.toString() ?? "",
-              stderr: stderr?.toString() ?? ""
-            })
+function parseYAML(yamlString) {
+  return YAML2.parse(yamlString);
+}
+
+// src/utils/error-formatter.ts
+function formatValidationErrors(errors) {
+  if (errors.length === 0) {
+    return "No validation errors.";
+  }
+  const formattedErrors = errors.map((error, index) => {
+    return `${index + 1}. ${error}`;
+  });
+  return `Validation failed with ${errors.length} error(s):
+
+${formattedErrors.join("\n")}`;
+}
+function createRetryPrompt(originalPrompt, errors, attemptNumber) {
+  const errorSummary = formatValidationErrors(errors);
+  return `${originalPrompt}
+
+---
+
+**VALIDATION FAILED (Attempt ${attemptNumber})**
+
+The previously generated YAML configuration did not pass validation:
+
+${errorSummary}
+
+Please analyze these errors and generate a corrected YAML configuration that addresses all validation issues.
+
+Remember:
+- Output pure YAML only (no markdown, no code blocks, no explanations)
+- Ensure all required fields are present
+- Follow the correct schema structure
+- Validate pattern syntax for targets and exclude arrays`;
+}
+
+// src/commands/CreateTemplate.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_RETRIES = 3;
+var CreateTemplateView = ({
+  printMode,
+  templateName
+}) => {
+  const { exit } = useApp2();
+  const [phase, setPhase] = useState2("init");
+  const [message, setMessage] = useState2("");
+  const [error, setError] = useState2(null);
+  const [prompt, setPrompt] = useState2("");
+  const [sessionId, setSessionId] = useState2(void 0);
+  const [attemptNumber, setAttemptNumber] = useState2(1);
+  useEffect2(() => {
+    (async () => {
+      try {
+        const templatesDir = getSubDir("templates");
+        await ensureDir(templatesDir);
+        const exampleTemplate = readAsset("template.example.yml");
+        const generatedPrompt = generateTemplateWizardPrompt({
+          exampleTemplate
+        });
+        setPrompt(generatedPrompt);
+        if (printMode) {
+          setPhase("done");
+          exit();
+          return;
+        }
+        if (!await isClaudeCodeAvailable()) {
+          throw new Error(
+            "Claude Code CLI not found. Install it or use --print mode to get the prompt."
+          );
+        }
+        await invokeLLMWithRetry(generatedPrompt, templatesDir);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  async function invokeLLMWithRetry(initialPrompt, templatesDir) {
+    let currentPrompt = initialPrompt;
+    let currentAttempt = 1;
+    let currentSessionId = sessionId;
+    while (currentAttempt <= MAX_RETRIES) {
+      try {
+        setPhase("llm-invoke");
+        setMessage(`Generating template... (Attempt ${currentAttempt}/${MAX_RETRIES})`);
+        const result = currentSessionId ? await resumeClaudeCodeSession(currentSessionId, currentPrompt) : await invokeClaudeCode(currentPrompt);
+        if (!result.success) {
+          throw new Error(result.error || "Failed to invoke Claude Code");
+        }
+        currentSessionId = result.sessionId;
+        setSessionId(currentSessionId);
+        setPhase("validating");
+        setMessage("Parsing YAML response...");
+        const yamlContent = extractYAML(result.output);
+        if (!yamlContent) {
+          throw new Error("No valid YAML found in LLM response");
+        }
+        const parsedTemplate = parseYAML(yamlContent);
+        setMessage("Validating template...");
+        const validation = validateTemplate(parsedTemplate);
+        if (validation.valid) {
+          setPhase("writing");
+          setMessage("Writing template...");
+          const filename = templateName ? `${templateName}.yml` : `${parsedTemplate.name.toLowerCase().replace(/\s+/g, "-")}.yml`;
+          const templatePath = join9(templatesDir, filename);
+          if (await fileExists(templatePath)) {
+            throw new Error(
+              `Template already exists: ${filename}
+Please choose a different name or delete the existing template.`
+            );
+          }
+          await writeFile4(templatePath, yamlContent, "utf-8");
+          setPhase("done");
+          setMessage(`\u2713 Template created: ${filename}`);
+          setTimeout(() => exit(), 100);
+          return;
+        }
+        if (currentAttempt >= MAX_RETRIES) {
+          throw new Error(
+            `Validation failed after ${MAX_RETRIES} attempts:
+${formatValidationErrors(validation.errors || [])}`
           );
-        } else {
-          resolve2({
-            stdout: stdout?.toString() ?? "",
-            stderr: stderr?.toString() ?? ""
-          });
         }
+        setPhase("retry");
+        setMessage(`Validation failed. Retrying with error context...`);
+        currentPrompt = createRetryPrompt(
+          initialPrompt,
+          validation.errors || [],
+          currentAttempt + 1
+        );
+        currentAttempt++;
+        setAttemptNumber(currentAttempt);
+      } catch (err) {
+        if (currentAttempt >= MAX_RETRIES) {
+          throw err;
+        }
+        currentAttempt++;
+        setAttemptNumber(currentAttempt);
       }
+    }
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  if (printMode && phase === "done") {
+    return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Create Template Prompt (Copy and paste to your LLM):" }),
+      /* @__PURE__ */ jsx3(Box2, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500".repeat(60) }) }),
+      /* @__PURE__ */ jsx3(Text3, { children: prompt }),
+      /* @__PURE__ */ jsx3(Box2, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500".repeat(60) }) }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "After getting the YAML response, save it to ~/.syncpoint/templates/" })
+    ] });
+  }
+  if (phase === "done") {
+    return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: message }),
+      /* @__PURE__ */ jsxs3(Box2, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { children: "Next steps:" }),
+        /* @__PURE__ */ jsx3(Text3, { children: "  1. Review your template: syncpoint list templates" }),
+        /* @__PURE__ */ jsx3(Text3, { children: "  2. Run provisioning: syncpoint provision <template-name>" })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: /* @__PURE__ */ jsx3(Spinner, { type: "dots" }) }),
+      " ",
+      message
+    ] }),
+    attemptNumber > 1 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "Attempt ",
+      attemptNumber,
+      "/",
+      MAX_RETRIES
+    ] })
+  ] });
+};
+function registerCreateTemplateCommand(program2) {
+  program2.command("create-template [name]").description("Interactive wizard to create a provisioning template").option("-p, --print", "Print prompt instead of invoking Claude Code").action(async (name, opts) => {
+    const { waitUntilExit } = render2(
+      /* @__PURE__ */ jsx3(CreateTemplateView, { printMode: opts.print || false, templateName: name })
     );
+    await waitUntilExit();
   });
 }
-async function evaluateSkipIf(command, stepName) {
-  if (containsRemoteScriptPattern(command)) {
-    throw new Error(`Blocked dangerous remote script pattern in skip_if: ${stepName}`);
-  }
-  try {
-    await execAsync(command);
-    return true;
-  } catch {
-    return false;
+
+// src/commands/Help.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { render as render3 } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var GeneralHelpView = () => {
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "SYNCPOINT - Personal Environment Manager" }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "USAGE" }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { children: "npx @lumy-pack/syncpoint <command> [options]" }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "AVAILABLE COMMANDS" }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsxs4(Box3, { marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "init" }),
+        "                    ",
+        "Initialize syncpoint directory structure"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "wizard" }),
+        "                  ",
+        "Generate config.yml with AI assistance"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "backup" }),
+        "                  ",
+        "Create compressed backup archive"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "restore [filename]" }),
+        "      ",
+        "Restore configuration files"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "provision <template>" }),
+        "    ",
+        "Run machine provisioning template"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "create-template [name]" }),
+        "  ",
+        "Create provisioning template with AI"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "list [type]" }),
+        "             ",
+        "Browse backups and templates"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "status" }),
+        "                  ",
+        "Show status and manage cleanup"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "help [command]" }),
+        "          ",
+        "Show help for specific command"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "GLOBAL OPTIONS" }),
+    /* @__PURE__ */ jsxs4(Box3, { marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "-V, --version" }),
+        "          ",
+        "Output the version number"
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "-h, --help" }),
+        "            ",
+        "Display help for command"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Run 'syncpoint help <command>' for detailed information about a specific command." })
+  ] });
+};
+var CommandDetailView = ({ command }) => {
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "COMMAND: " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: command.name })
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "DESCRIPTION" }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { children: command.description }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "USAGE" }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { children: command.usage }) }),
+    /* @__PURE__ */ jsx4(Text4, { children: "" }),
+    command.arguments && command.arguments.length > 0 && /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "ARGUMENTS" }),
+      /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, flexDirection: "column", children: command.arguments.map((arg, idx) => /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: arg.required ? `<${arg.name}>` : `[${arg.name}]` }),
+        "  ",
+        arg.description
+      ] }, idx)) }),
+      /* @__PURE__ */ jsx4(Text4, { children: "" })
+    ] }),
+    command.options && command.options.length > 0 && /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "OPTIONS" }),
+      /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, flexDirection: "column", children: command.options.map((opt, idx) => /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: opt.flag }),
+        opt.flag.length < 20 && " ".repeat(20 - opt.flag.length),
+        opt.description,
+        opt.default && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          " (default: ",
+          opt.default,
+          ")"
+        ] })
+      ] }, idx)) }),
+      /* @__PURE__ */ jsx4(Text4, { children: "" })
+    ] }),
+    command.examples && command.examples.length > 0 && /* @__PURE__ */ jsxs4(Fragment, { children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: true, children: "EXAMPLES" }),
+      /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, flexDirection: "column", children: command.examples.map((example, idx) => /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: example }, idx)) })
+    ] })
+  ] });
+};
+var HelpView = ({ commandName }) => {
+  if (commandName) {
+    const commandInfo = COMMANDS[commandName];
+    if (!commandInfo) {
+      return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+          "\u2717 Unknown command: ",
+          commandName
+        ] }),
+        /* @__PURE__ */ jsx4(Text4, { children: "" }),
+        /* @__PURE__ */ jsx4(Text4, { children: "Run 'syncpoint help' to see all available commands." })
+      ] });
+    }
+    return /* @__PURE__ */ jsx4(CommandDetailView, { command: commandInfo });
   }
+  return /* @__PURE__ */ jsx4(GeneralHelpView, {});
+};
+function registerHelpCommand(program2) {
+  program2.command("help [command]").description("Display help information").action(async (commandName) => {
+    const { waitUntilExit } = render3(/* @__PURE__ */ jsx4(HelpView, { commandName }));
+    await waitUntilExit();
+  });
 }
-async function executeStep(step) {
-  const startTime = Date.now();
-  if (containsRemoteScriptPattern(step.command)) {
-    throw new Error(`Blocked dangerous remote script pattern in command: ${step.name}`);
-  }
-  if (step.skip_if) {
-    const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
-    if (shouldSkip) {
-      return {
-        name: step.name,
-        status: "skipped",
-        duration: Date.now() - startTime
-      };
-    }
+
+// src/commands/Init.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Text as Text5, Box as Box4, useApp as useApp3 } from "ink";
+import { render as render4 } from "ink";
+import { join as join10 } from "path";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var InitView = () => {
+  const { exit } = useApp3();
+  const [steps, setSteps] = useState3([]);
+  const [error, setError] = useState3(null);
+  const [complete, setComplete] = useState3(false);
+  useEffect3(() => {
+    (async () => {
+      try {
+        const appDir = getAppDir();
+        if (await fileExists(join10(appDir, CONFIG_FILENAME))) {
+          setError(`Already initialized: ${appDir}`);
+          exit();
+          return;
+        }
+        const dirs = [
+          { name: appDir, label: `~/.${APP_NAME}/` },
+          {
+            name: getSubDir(BACKUPS_DIR),
+            label: `~/.${APP_NAME}/${BACKUPS_DIR}/`
+          },
+          {
+            name: getSubDir(TEMPLATES_DIR),
+            label: `~/.${APP_NAME}/${TEMPLATES_DIR}/`
+          },
+          {
+            name: getSubDir(SCRIPTS_DIR),
+            label: `~/.${APP_NAME}/${SCRIPTS_DIR}/`
+          },
+          {
+            name: getSubDir(LOGS_DIR),
+            label: `~/.${APP_NAME}/${LOGS_DIR}/`
+          }
+        ];
+        const completed = [];
+        for (const dir of dirs) {
+          await ensureDir(dir.name);
+          completed.push({ name: `Created ${dir.label}`, done: true });
+          setSteps([...completed]);
+        }
+        await initDefaultConfig();
+        completed.push({ name: `Created ${CONFIG_FILENAME} (defaults)`, done: true });
+        setSteps([...completed]);
+        const exampleTemplatePath = join10(getSubDir(TEMPLATES_DIR), "example.yml");
+        if (!await fileExists(exampleTemplatePath)) {
+          const { writeFile: writeFile6 } = await import("fs/promises");
+          const exampleYaml = readAsset("template.example.yml");
+          await writeFile6(exampleTemplatePath, exampleYaml, "utf-8");
+          completed.push({ name: `Created templates/example.yml`, done: true });
+          setSteps([...completed]);
+        }
+        setComplete(true);
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        exit();
+      }
+    })();
+  }, []);
+  if (error) {
+    return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", children: /* @__PURE__ */ jsxs5(Text5, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
   }
-  try {
-    const { stdout, stderr } = await execAsync(step.command);
-    const output = [stdout, stderr].filter(Boolean).join("\n").trim();
-    return {
-      name: step.name,
-      status: "success",
-      duration: Date.now() - startTime,
-      output: output || void 0
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
+    steps.map((step, idx) => /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" }),
+      " ",
+      step.name
+    ] }, idx)),
+    complete && /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Initialization complete! Next steps:" }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        "1. Edit config.yml to specify backup targets"
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        "     ",
+        "\u2192 ~/.",
+        APP_NAME,
+        "/",
+        CONFIG_FILENAME
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        "  ",
+        "2. Run ",
+        APP_NAME,
+        " backup to create your first snapshot"
+      ] })
+    ] })
+  ] });
+};
+function registerInitCommand(program2) {
+  program2.command("init").description(`Initialize ~/.${APP_NAME}/ directory structure and default config`).action(async () => {
+    const { waitUntilExit } = render4(/* @__PURE__ */ jsx5(InitView, {}));
+    await waitUntilExit();
+  });
+}
+
+// src/commands/List.tsx
+import { unlinkSync } from "fs";
+import { Box as Box6, Text as Text8, useApp as useApp4, useInput as useInput2 } from "ink";
+import { render as render5 } from "ink";
+import SelectInput from "ink-select-input";
+import { useEffect as useEffect4, useState as useState5 } from "react";
+
+// src/components/Confirm.tsx
+import { Text as Text6, useInput } from "ink";
+import { useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var Confirm = ({
+  message,
+  onConfirm,
+  defaultYes = true
+}) => {
+  const [answered, setAnswered] = useState4(false);
+  useInput((input, key) => {
+    if (answered) return;
+    if (input === "y" || input === "Y") {
+      setAnswered(true);
+      onConfirm(true);
+    } else if (input === "n" || input === "N") {
+      setAnswered(true);
+      onConfirm(false);
+    } else if (key.return) {
+      setAnswered(true);
+      onConfirm(defaultYes);
+    }
+  });
+  const yText = defaultYes ? /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Y" }) : /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "y" });
+  const nText = defaultYes ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "n" }) : /* @__PURE__ */ jsx6(Text6, { bold: true, children: "N" });
+  return /* @__PURE__ */ jsxs6(Text6, { children: [
+    /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "? " }),
+    message,
+    " ",
+    /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "[" }),
+    yText,
+    /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "/" }),
+    nText,
+    /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "]" })
+  ] });
+};
+
+// src/components/Table.tsx
+import { Text as Text7, Box as Box5 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var Table = ({
+  headers,
+  rows,
+  columnWidths
+}) => {
+  const widths = columnWidths ?? headers.map((header, colIdx) => {
+    const dataMax = rows.reduce(
+      (max, row) => Math.max(max, (row[colIdx] ?? "").length),
+      0
+    );
+    return Math.max(header.length, dataMax) + 2;
+  });
+  const padCell = (text, width) => {
+    return text.padEnd(width);
+  };
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
+  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Text7, { children: headers.map((h, i) => /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+      padCell(h, widths[i]),
+      i < headers.length - 1 ? "  " : ""
+    ] }, i)) }),
+    /* @__PURE__ */ jsx7(Text7, { color: "gray", children: separator }),
+    rows.map((row, rowIdx) => /* @__PURE__ */ jsx7(Text7, { children: row.map((cell, colIdx) => /* @__PURE__ */ jsxs7(Text7, { children: [
+      padCell(cell, widths[colIdx]),
+      colIdx < row.length - 1 ? "  " : ""
+    ] }, colIdx)) }, rowIdx))
+  ] });
+};
+
+// src/core/provision.ts
+import { exec } from "child_process";
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import { join as join11 } from "path";
+import YAML3 from "yaml";
+var REMOTE_SCRIPT_PATTERNS = [
+  /curl\s.*\|\s*(ba)?sh/,
+  /wget\s.*\|\s*(ba)?sh/,
+  /curl\s.*\|\s*python/,
+  /wget\s.*\|\s*python/
+];
+function containsRemoteScriptPattern(command) {
+  return REMOTE_SCRIPT_PATTERNS.some((p) => p.test(command));
+}
+function sanitizeErrorOutput(output) {
+  return output.replace(/\/Users\/[^\s/]+/g, "/Users/***").replace(/\/home\/[^\s/]+/g, "/home/***").replace(/(password|token|key|secret)[=:]\s*\S+/gi, "$1=***").slice(0, 500);
+}
+async function loadTemplate(templatePath) {
+  const exists = await fileExists(templatePath);
+  if (!exists) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+  const raw = await readFile4(templatePath, "utf-8");
+  const data = YAML3.parse(raw);
+  const result = validateTemplate(data);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid template ${templatePath}:
+${(result.errors ?? []).join("\n")}`
+    );
+  }
+  return data;
+}
+async function listTemplates() {
+  const templatesDir = getSubDir(TEMPLATES_DIR);
+  const exists = await fileExists(templatesDir);
+  if (!exists) return [];
+  const entries = await readdir2(templatesDir, { withFileTypes: true });
+  const templates = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".yml") && !entry.name.endsWith(".yaml")) {
+      continue;
+    }
+    const fullPath = join11(templatesDir, entry.name);
+    try {
+      const config = await loadTemplate(fullPath);
+      templates.push({
+        name: entry.name.replace(/\.ya?ml$/, ""),
+        path: fullPath,
+        config
+      });
+    } catch {
+      logger.warn(`Skipping invalid template: ${entry.name}`);
+    }
+  }
+  return templates;
+}
+function execAsync(command) {
+  return new Promise((resolve2, reject) => {
+    exec(
+      command,
+      { shell: "/bin/bash", timeout: 3e5 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            Object.assign(error, {
+              stdout: stdout?.toString() ?? "",
+              stderr: stderr?.toString() ?? ""
+            })
+          );
+        } else {
+          resolve2({
+            stdout: stdout?.toString() ?? "",
+            stderr: stderr?.toString() ?? ""
+          });
+        }
+      }
+    );
+  });
+}
+async function evaluateSkipIf(command, stepName) {
+  if (containsRemoteScriptPattern(command)) {
+    throw new Error(
+      `Blocked dangerous remote script pattern in skip_if: ${stepName}`
+    );
+  }
+  try {
+    await execAsync(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function executeStep(step) {
+  const startTime = Date.now();
+  if (containsRemoteScriptPattern(step.command)) {
+    throw new Error(
+      `Blocked dangerous remote script pattern in command: ${step.name}`
+    );
+  }
+  if (step.skip_if) {
+    const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
+    if (shouldSkip) {
+      return {
+        name: step.name,
+        status: "skipped",
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  try {
+    const { stdout, stderr } = await execAsync(step.command);
+    const output = [stdout, stderr].filter(Boolean).join("\n").trim();
+    return {
+      name: step.name,
+      status: "success",
+      duration: Date.now() - startTime,
+      output: output || void 0
+    };
+  } catch (err) {
+    const error = err;
+    const errorOutput = [error.stdout, error.stderr, error.message].filter(Boolean).join("\n").trim();
+    return {
+      name: step.name,
+      status: "failed",
+      duration: Date.now() - startTime,
+      error: sanitizeErrorOutput(errorOutput)
+    };
+  }
+}
+async function* runProvision(templatePath, options = {}) {
+  const template = await loadTemplate(templatePath);
+  for (const step of template.steps) {
+    if (options.dryRun) {
+      let status = "pending";
+      if (step.skip_if) {
+        const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
+        if (shouldSkip) status = "skipped";
+      }
+      yield {
+        name: step.name,
+        status
+      };
+      continue;
+    }
+    yield {
+      name: step.name,
+      status: "running"
+    };
+    const result = await executeStep(step);
+    yield result;
+    if (result.status === "failed" && !step.continue_on_error) {
+      logger.error(`Step "${step.name}" failed. Stopping provisioning.`);
+      return;
+    }
+  }
+}
+
+// src/core/restore.ts
+import { copyFile, lstat as lstat2, readdir as readdir3, stat as stat2 } from "fs/promises";
+import { dirname as dirname2, join as join12 } from "path";
+async function getBackupList(config) {
+  const backupDir = config?.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir(BACKUPS_DIR);
+  const exists = await fileExists(backupDir);
+  if (!exists) return [];
+  const entries = await readdir3(backupDir, { withFileTypes: true });
+  const backups = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".tar.gz")) continue;
+    const fullPath = join12(backupDir, entry.name);
+    const fileStat = await stat2(fullPath);
+    let hostname;
+    let fileCount;
+    try {
+      const metaBuf = await readFileFromArchive(fullPath, METADATA_FILENAME);
+      if (metaBuf) {
+        const meta = parseMetadata(metaBuf);
+        hostname = meta.hostname;
+        fileCount = meta.summary.fileCount;
+      }
+    } catch {
+      logger.info(`Could not read metadata from: ${entry.name}`);
+    }
+    backups.push({
+      filename: entry.name,
+      path: fullPath,
+      size: fileStat.size,
+      createdAt: fileStat.mtime,
+      hostname,
+      fileCount
+    });
+  }
+  backups.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  return backups;
+}
+async function getRestorePlan(archivePath) {
+  const metaBuf = await readFileFromArchive(archivePath, METADATA_FILENAME);
+  if (!metaBuf) {
+    throw new Error(
+      `No metadata found in archive: ${archivePath}
+This may not be a valid syncpoint backup.`
+    );
+  }
+  const metadata = parseMetadata(metaBuf);
+  const actions = [];
+  for (const file of metadata.files) {
+    const absPath = resolveTargetPath(file.path);
+    const exists = await fileExists(absPath);
+    if (!exists) {
+      actions.push({
+        path: file.path,
+        action: "create",
+        backupSize: file.size,
+        reason: "File does not exist on this machine"
+      });
+      continue;
+    }
+    const currentHash = await computeFileHash(absPath);
+    const currentStat = await stat2(absPath);
+    if (currentHash === file.hash) {
+      actions.push({
+        path: file.path,
+        action: "skip",
+        currentSize: currentStat.size,
+        backupSize: file.size,
+        reason: "File is identical (same hash)"
+      });
+    } else {
+      actions.push({
+        path: file.path,
+        action: "overwrite",
+        currentSize: currentStat.size,
+        backupSize: file.size,
+        reason: "File has been modified"
+      });
+    }
+  }
+  return { metadata, actions };
+}
+async function createSafetyBackup(filePaths) {
+  const now = /* @__PURE__ */ new Date();
+  const filename = `_pre-restore_${formatDatetime(now)}.tar.gz`;
+  const backupDir = getSubDir(BACKUPS_DIR);
+  await ensureDir(backupDir);
+  const archivePath = join12(backupDir, filename);
+  const files = [];
+  for (const fp of filePaths) {
+    const absPath = resolveTargetPath(fp);
+    const exists = await fileExists(absPath);
+    if (!exists) continue;
+    const archiveName = fp.startsWith("~/") ? fp.slice(2) : fp;
+    files.push({ name: archiveName, sourcePath: absPath });
+  }
+  if (files.length === 0) {
+    logger.info("No existing files to safety-backup.");
+    return archivePath;
+  }
+  await createArchive(files, archivePath);
+  logger.info(`Safety backup created: ${archivePath}`);
+  return archivePath;
+}
+async function restoreBackup(archivePath, options = {}) {
+  const plan = await getRestorePlan(archivePath);
+  const restoredFiles = [];
+  const skippedFiles = [];
+  const overwritePaths = plan.actions.filter((a) => a.action === "overwrite").map((a) => a.path);
+  let safetyBackupPath;
+  if (overwritePaths.length > 0 && !options.dryRun) {
+    safetyBackupPath = await createSafetyBackup(overwritePaths);
+  }
+  if (options.dryRun) {
+    return {
+      restoredFiles: plan.actions.filter((a) => a.action !== "skip").map((a) => a.path),
+      skippedFiles: plan.actions.filter((a) => a.action === "skip").map((a) => a.path),
+      safetyBackupPath
+    };
+  }
+  const { mkdtemp: mkdtemp2, rm: rm2 } = await import("fs/promises");
+  const { tmpdir: tmpdir3 } = await import("os");
+  const tmpDir = await mkdtemp2(join12(tmpdir3(), "syncpoint-restore-"));
+  try {
+    await extractArchive(archivePath, tmpDir);
+    for (const action of plan.actions) {
+      if (action.action === "skip") {
+        skippedFiles.push(action.path);
+        continue;
+      }
+      const archiveName = action.path.startsWith("~/") ? action.path.slice(2) : action.path;
+      const extractedPath = join12(tmpDir, archiveName);
+      const destPath = resolveTargetPath(action.path);
+      const extractedExists = await fileExists(extractedPath);
+      if (!extractedExists) {
+        logger.warn(`File not found in archive: ${archiveName}`);
+        skippedFiles.push(action.path);
+        continue;
+      }
+      await ensureDir(dirname2(destPath));
+      try {
+        const destStat = await lstat2(destPath);
+        if (destStat.isSymbolicLink()) {
+          logger.warn(`Skipping symlink target: ${action.path}`);
+          skippedFiles.push(action.path);
+          continue;
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+      await copyFile(extractedPath, destPath);
+      restoredFiles.push(action.path);
+    }
+  } finally {
+    await rm2(tmpDir, { recursive: true, force: true });
+  }
+  return { restoredFiles, skippedFiles, safetyBackupPath };
+}
+
+// src/commands/List.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var MenuItem = ({ isSelected = false, label }) => {
+  if (label === "Delete") {
+    return /* @__PURE__ */ jsx8(Text8, { bold: isSelected, color: "red", children: label });
+  }
+  const match = label.match(/^(.+?)\s+\((\d+)\)$/);
+  if (match) {
+    const [, name, count] = match;
+    return /* @__PURE__ */ jsxs8(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: isSelected, children: name }),
+      " ",
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "(",
+        count,
+        ")"
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsx8(Text8, { bold: isSelected, children: label });
+};
+var ListView = ({ type, deleteIndex }) => {
+  const { exit } = useApp4();
+  const [phase, setPhase] = useState5("loading");
+  const [backups, setBackups] = useState5([]);
+  const [templates, setTemplates] = useState5([]);
+  const [selectedTemplate, setSelectedTemplate] = useState5(
+    null
+  );
+  const [selectedBackup, setSelectedBackup] = useState5(null);
+  const [deleteTarget, setDeleteTarget] = useState5(null);
+  const [error, setError] = useState5(null);
+  const [backupDir, setBackupDir] = useState5(getSubDir("backups"));
+  useInput2((_input, key) => {
+    if (!key.escape) return;
+    switch (phase) {
+      case "main-menu":
+        exit();
+        break;
+      case "backup-list":
+      case "template-list":
+        setSelectedBackup(null);
+        setSelectedTemplate(null);
+        setPhase("main-menu");
+        break;
+      case "backup-detail":
+        setSelectedBackup(null);
+        setPhase("backup-list");
+        break;
+      case "template-detail":
+        setSelectedTemplate(null);
+        setPhase("template-list");
+        break;
+    }
+  });
+  useEffect4(() => {
+    (async () => {
+      try {
+        const config = await loadConfig();
+        const backupDirectory = config.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir("backups");
+        setBackupDir(backupDirectory);
+        const showBackups = !type || type === "backups";
+        const showTemplates = !type || type === "templates";
+        if (showBackups) {
+          const list2 = await getBackupList(config);
+          setBackups(list2);
+        }
+        if (showTemplates) {
+          const tmpls = await listTemplates();
+          setTemplates(tmpls);
+        }
+        if (deleteIndex != null && type === "backups") {
+          const list2 = await getBackupList(config);
+          const idx = deleteIndex - 1;
+          if (idx < 0 || idx >= list2.length) {
+            setError(`Invalid index: ${deleteIndex}`);
+            setPhase("error");
+            setTimeout(() => exit(), 100);
+            return;
+          }
+          setDeleteTarget({
+            name: list2[idx].filename,
+            path: list2[idx].path
+          });
+          setPhase("deleting");
+          return;
+        }
+        setPhase("main-menu");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  const goBackToMainMenu = () => {
+    setSelectedBackup(null);
+    setSelectedTemplate(null);
+    setPhase("main-menu");
+  };
+  const goBackToBackupList = () => {
+    setSelectedBackup(null);
+    setPhase("backup-list");
+  };
+  const goBackToTemplateList = () => {
+    setSelectedTemplate(null);
+    setPhase("template-list");
+  };
+  const handleDeleteConfirm = (yes) => {
+    if (yes && deleteTarget) {
+      try {
+        if (!isInsideDir(deleteTarget.path, backupDir)) {
+          throw new Error(`Refusing to delete file outside backups directory: ${deleteTarget.path}`);
+        }
+        unlinkSync(deleteTarget.path);
+        setPhase("done");
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    } else {
+      setDeleteTarget(null);
+      if (selectedBackup) {
+        setPhase("backup-detail");
+      } else {
+        goBackToMainMenu();
+      }
+    }
+  };
+  if (phase === "error" || error) {
+    return /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  if (phase === "loading") {
+    return /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: "Loading..." });
+  }
+  if (phase === "deleting" && deleteTarget) {
+    return /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsx8(
+      Confirm,
+      {
+        message: `Delete ${deleteTarget.name}?`,
+        onConfirm: handleDeleteConfirm,
+        defaultYes: false
+      }
+    ) });
+  }
+  if (phase === "done" && deleteTarget) {
+    return /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
+      "\u2713 ",
+      deleteTarget.name,
+      " deleted"
+    ] });
+  }
+  if (phase === "main-menu") {
+    const showBackups = !type || type === "backups";
+    const showTemplates = !type || type === "templates";
+    const menuItems = [];
+    if (showBackups) {
+      menuItems.push({
+        label: `Backups (${backups.length})`,
+        value: "backups"
+      });
+    }
+    if (showTemplates) {
+      menuItems.push({
+        label: `Templates (${templates.length})`,
+        value: "templates"
+      });
+    }
+    menuItems.push({ label: "Exit", value: "exit" });
+    const handleMainMenu = (item) => {
+      if (item.value === "exit") {
+        exit();
+      } else if (item.value === "backups") {
+        setPhase("backup-list");
+      } else if (item.value === "templates") {
+        setPhase("template-list");
+      }
+    };
+    return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(
+        SelectInput,
+        {
+          items: menuItems,
+          onSelect: handleMainMenu,
+          itemComponent: MenuItem
+        }
+      ),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "ESC" }),
+        " to exit"
+      ] }) })
+    ] });
+  }
+  if (phase === "backup-list") {
+    const items = backups.map((b) => ({
+      label: `${b.filename.replace(".tar.gz", "")}  \u2022  ${formatBytes(b.size)}  \u2022  ${formatDate(b.createdAt)}`,
+      value: b.path
+    }));
+    const handleBackupSelect = (item) => {
+      const backup = backups.find((b) => b.path === item.value);
+      if (backup) {
+        setSelectedBackup(backup);
+        setPhase("backup-detail");
+      }
+    };
+    return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "\u25B8 Backups" }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: backups.length === 0 ? /* @__PURE__ */ jsx8(Text8, { color: "gray", children: " No backups found." }) : /* @__PURE__ */ jsx8(
+        SelectInput,
+        {
+          items,
+          onSelect: handleBackupSelect,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  if (phase === "template-list") {
+    const items = templates.map((t) => ({
+      label: t.config.description ? `${t.config.name}  \u2014  ${t.config.description}` : t.config.name,
+      value: t.path
+    }));
+    const handleTemplateSelect = (item) => {
+      const tmpl = templates.find((t) => t.path === item.value);
+      if (tmpl) {
+        setSelectedTemplate(tmpl);
+        setPhase("template-detail");
+      }
     };
-  } catch (err) {
-    const error = err;
-    const errorOutput = [error.stdout, error.stderr, error.message].filter(Boolean).join("\n").trim();
-    return {
-      name: step.name,
-      status: "failed",
-      duration: Date.now() - startTime,
-      error: sanitizeErrorOutput(errorOutput)
+    return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "\u25B8 Templates" }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: templates.length === 0 ? /* @__PURE__ */ jsx8(Text8, { color: "gray", children: " No templates found." }) : /* @__PURE__ */ jsx8(
+        SelectInput,
+        {
+          items,
+          onSelect: handleTemplateSelect,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
+  }
+  if (phase === "backup-detail" && selectedBackup) {
+    const sections = [
+      { label: "Filename", value: selectedBackup.filename },
+      { label: "Date", value: formatDate(selectedBackup.createdAt) },
+      { label: "Size", value: formatBytes(selectedBackup.size) },
+      ...selectedBackup.hostname ? [{ label: "Hostname", value: selectedBackup.hostname }] : [],
+      ...selectedBackup.fileCount != null ? [{ label: "Files", value: String(selectedBackup.fileCount) }] : []
+    ];
+    const actionItems = [
+      { label: "Delete", value: "delete" },
+      { label: "Cancel", value: "cancel" }
+    ];
+    const handleDetailAction = (item) => {
+      if (item.value === "delete") {
+        setDeleteTarget({
+          name: selectedBackup.filename,
+          path: selectedBackup.path
+        });
+        setPhase("deleting");
+      } else if (item.value === "cancel") {
+        goBackToBackupList();
+      }
     };
+    return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+        "\u25B8 ",
+        selectedBackup.filename.replace(".tar.gz", "")
+      ] }),
+      /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => {
+        const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
+        return /* @__PURE__ */ jsxs8(Box6, { children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: section.label.padEnd(labelWidth) }),
+          /* @__PURE__ */ jsx8(Text8, { children: " " }),
+          /* @__PURE__ */ jsx8(Text8, { children: section.value })
+        ] }, idx);
+      }) }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx8(
+        SelectInput,
+        {
+          items: actionItems,
+          onSelect: handleDetailAction,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
   }
-}
-async function* runProvision(templatePath, options = {}) {
-  const template = await loadTemplate(templatePath);
-  for (const step of template.steps) {
-    if (options.dryRun) {
-      let status = "pending";
-      if (step.skip_if) {
-        const shouldSkip = await evaluateSkipIf(step.skip_if, step.name);
-        if (shouldSkip) status = "skipped";
+  if (phase === "template-detail" && selectedTemplate) {
+    const t = selectedTemplate.config;
+    const sections = [
+      { label: "Name", value: t.name },
+      ...t.description ? [{ label: "Description", value: t.description }] : [],
+      ...t.backup ? [{ label: "Backup link", value: t.backup }] : [],
+      { label: "Steps", value: String(t.steps.length) }
+    ];
+    const actionItems = [{ label: "Cancel", value: "cancel" }];
+    const handleDetailAction = (item) => {
+      if (item.value === "cancel") {
+        goBackToTemplateList();
       }
-      yield {
-        name: step.name,
-        status
-      };
-      continue;
-    }
-    yield {
-      name: step.name,
-      status: "running"
     };
-    const result = await executeStep(step);
-    yield result;
-    if (result.status === "failed" && !step.continue_on_error) {
-      logger.error(
-        `Step "${step.name}" failed. Stopping provisioning.`
-      );
-      return;
-    }
+    const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
+    return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+        "\u25B8 ",
+        selectedTemplate.name
+      ] }),
+      /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => /* @__PURE__ */ jsxs8(Box6, { children: [
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: section.label.padEnd(labelWidth) }),
+        /* @__PURE__ */ jsx8(Text8, { children: " " }),
+        /* @__PURE__ */ jsx8(Text8, { children: section.value })
+      ] }, idx)) }),
+      t.steps.length > 0 && /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " Provisioning Steps" }),
+        /* @__PURE__ */ jsx8(Box6, { marginLeft: 2, children: /* @__PURE__ */ jsx8(
+          Table,
+          {
+            headers: ["#", "Step", "Description"],
+            rows: t.steps.map((s, idx) => [
+              String(idx + 1),
+              s.name,
+              s.description ?? "\u2014"
+            ])
+          }
+        ) })
+      ] }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx8(
+        SelectInput,
+        {
+          items: actionItems,
+          onSelect: handleDetailAction,
+          itemComponent: MenuItem
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        "Press ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "ESC" }),
+        " to go back"
+      ] }) })
+    ] });
   }
+  return null;
+};
+function registerListCommand(program2) {
+  program2.command("list [type]").description("List backups and templates").option("--delete <n>", "Delete item #n").action(async (type, opts) => {
+    const deleteIndex = opts.delete ? parseInt(opts.delete, 10) : void 0;
+    const { waitUntilExit } = render5(
+      /* @__PURE__ */ jsx8(ListView, { type, deleteIndex })
+    );
+    await waitUntilExit();
+  });
 }
 
+// src/commands/Provision.tsx
+import { useState as useState6, useEffect as useEffect5 } from "react";
+import { Text as Text10, Box as Box8, useApp as useApp5 } from "ink";
+import { render as render6 } from "ink";
+
 // src/utils/sudo.ts
 import { execSync } from "child_process";
 import pc2 from "picocolors";
@@ -1590,37 +2641,37 @@ ${pc2.red("\u2717")} Sudo authentication failed or was cancelled. Aborting.`
 }
 
 // src/components/StepRunner.tsx
-import { Text as Text6, Box as Box4 } from "ink";
-import Spinner from "ink-spinner";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Text as Text9, Box as Box7 } from "ink";
+import Spinner2 from "ink-spinner";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
 var StepIcon = ({ status }) => {
   switch (status) {
     case "success":
-      return /* @__PURE__ */ jsx6(Text6, { color: "green", children: "\u2713" });
+      return /* @__PURE__ */ jsx9(Text9, { color: "green", children: "\u2713" });
     case "running":
-      return /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: /* @__PURE__ */ jsx6(Spinner, { type: "dots" }) });
+      return /* @__PURE__ */ jsx9(Text9, { color: "yellow", children: /* @__PURE__ */ jsx9(Spinner2, { type: "dots" }) });
     case "skipped":
-      return /* @__PURE__ */ jsx6(Text6, { color: "blue", children: "\u23ED" });
+      return /* @__PURE__ */ jsx9(Text9, { color: "blue", children: "\u23ED" });
     case "failed":
-      return /* @__PURE__ */ jsx6(Text6, { color: "red", children: "\u2717" });
+      return /* @__PURE__ */ jsx9(Text9, { color: "red", children: "\u2717" });
     case "pending":
     default:
-      return /* @__PURE__ */ jsx6(Text6, { color: "gray", children: "\u25CB" });
+      return /* @__PURE__ */ jsx9(Text9, { color: "gray", children: "\u25CB" });
   }
 };
 var StepStatusText = ({ step }) => {
   switch (step.status) {
     case "success":
-      return /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
+      return /* @__PURE__ */ jsxs9(Text9, { color: "green", children: [
         "Done",
         step.duration != null ? ` (${Math.round(step.duration / 1e3)}s)` : ""
       ] });
     case "running":
-      return /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "Running..." });
+      return /* @__PURE__ */ jsx9(Text9, { color: "yellow", children: "Running..." });
     case "skipped":
-      return /* @__PURE__ */ jsx6(Text6, { color: "blue", children: "Skipped (already installed)" });
+      return /* @__PURE__ */ jsx9(Text9, { color: "blue", children: "Skipped (already installed)" });
     case "failed":
-      return /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
+      return /* @__PURE__ */ jsxs9(Text9, { color: "red", children: [
         "Failed",
         step.error ? `: ${step.error}` : ""
       ] });
@@ -1633,13 +2684,13 @@ var StepRunner = ({
   steps,
   total
 }) => {
-  return /* @__PURE__ */ jsx6(Box4, { flexDirection: "column", children: steps.map((step, idx) => /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", marginBottom: idx < steps.length - 1 ? 1 : 0, children: [
-    /* @__PURE__ */ jsxs6(Text6, { children: [
+  return /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", children: steps.map((step, idx) => /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", marginBottom: idx < steps.length - 1 ? 1 : 0, children: [
+    /* @__PURE__ */ jsxs9(Text9, { children: [
       "  ",
-      /* @__PURE__ */ jsx6(StepIcon, { status: step.status }),
-      /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx9(StepIcon, { status: step.status }),
+      /* @__PURE__ */ jsxs9(Text9, { children: [
         " ",
-        /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
+        /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
           "Step ",
           idx + 1,
           "/",
@@ -1649,36 +2700,36 @@ var StepRunner = ({
         step.name
       ] })
     ] }),
-    step.output && step.status !== "pending" && /* @__PURE__ */ jsxs6(Text6, { color: "gray", children: [
+    step.output && step.status !== "pending" && /* @__PURE__ */ jsxs9(Text9, { color: "gray", children: [
       "            ",
       step.output
     ] }),
-    /* @__PURE__ */ jsxs6(Text6, { children: [
+    /* @__PURE__ */ jsxs9(Text9, { children: [
       "            ",
-      /* @__PURE__ */ jsx6(StepStatusText, { step })
+      /* @__PURE__ */ jsx9(StepStatusText, { step })
     ] })
   ] }, idx)) });
 };
 
 // src/commands/Provision.tsx
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
 var ProvisionView = ({
   template,
   templatePath,
   options
 }) => {
-  const { exit } = useApp4();
-  const [phase, setPhase] = useState5(options.dryRun ? "done" : "running");
-  const [steps, setSteps] = useState5(
+  const { exit } = useApp5();
+  const [phase, setPhase] = useState6(options.dryRun ? "done" : "running");
+  const [steps, setSteps] = useState6(
     template.steps.map((s) => ({
       name: s.name,
       status: "pending",
       output: s.description
     }))
   );
-  const [currentStep, setCurrentStep] = useState5(0);
-  const [error, setError] = useState5(null);
-  useEffect4(() => {
+  const [currentStep, setCurrentStep] = useState6(0);
+  const [error, setError] = useState6(null);
+  useEffect5(() => {
     if (options.dryRun) {
       setTimeout(() => exit(), 100);
       return;
@@ -1708,7 +2759,7 @@ var ProvisionView = ({
     })();
   }, []);
   if (phase === "error" || error) {
-    return /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", children: /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
       "\u2717 ",
       error
     ] }) });
@@ -1716,27 +2767,27 @@ var ProvisionView = ({
   const successCount = steps.filter((s) => s.status === "success").length;
   const skippedCount = steps.filter((s) => s.status === "skipped").length;
   const failedCount = steps.filter((s) => s.status === "failed").length;
-  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+  return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs10(Text10, { bold: true, children: [
         "\u25B8 ",
         template.name
       ] }),
-      template.description && /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+      template.description && /* @__PURE__ */ jsxs10(Text10, { color: "gray", children: [
         "  ",
         template.description
       ] })
     ] }),
-    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "(dry-run) Showing execution plan only" }),
-      template.sudo && /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
+    options.dryRun && phase === "done" && /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text10, { color: "yellow", children: "(dry-run) Showing execution plan only" }),
+      template.sudo && /* @__PURE__ */ jsxs10(Text10, { color: "yellow", children: [
         "  ",
         "\u26A0 This template requires sudo privileges (will prompt on actual run)"
       ] }),
-      /* @__PURE__ */ jsx7(Box5, { flexDirection: "column", marginTop: 1, children: template.steps.map((step, idx) => /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginBottom: 1, children: [
-        /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", marginTop: 1, children: template.steps.map((step, idx) => /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs10(Text10, { children: [
           "  ",
-          /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+          /* @__PURE__ */ jsxs10(Text10, { bold: true, children: [
             "Step ",
             idx + 1,
             "/",
@@ -1745,18 +2796,18 @@ var ProvisionView = ({
           "  ",
           step.name
         ] }),
-        step.description && /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+        step.description && /* @__PURE__ */ jsxs10(Text10, { color: "gray", children: [
           "            ",
           step.description
         ] }),
-        step.skip_if && /* @__PURE__ */ jsxs7(Text7, { color: "blue", children: [
+        step.skip_if && /* @__PURE__ */ jsxs10(Text10, { color: "blue", children: [
           "            ",
           "Skip condition: ",
           step.skip_if
         ] })
       ] }, idx)) })
     ] }),
-    (phase === "running" || phase === "done" && !options.dryRun) && /* @__PURE__ */ jsx7(
+    (phase === "running" || phase === "done" && !options.dryRun) && /* @__PURE__ */ jsx10(
       StepRunner,
       {
         steps,
@@ -1764,34 +2815,34 @@ var ProvisionView = ({
         total: template.steps.length
       }
     ),
-    phase === "done" && !options.dryRun && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+    phase === "done" && !options.dryRun && /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs10(Text10, { color: "gray", children: [
         "  ",
         "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
       ] }),
-      /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsxs10(Text10, { children: [
         "  ",
         "Result: ",
-        /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
+        /* @__PURE__ */ jsxs10(Text10, { color: "green", children: [
           successCount,
           " succeeded"
         ] }),
         " \xB7",
         " ",
-        /* @__PURE__ */ jsxs7(Text7, { color: "blue", children: [
+        /* @__PURE__ */ jsxs10(Text10, { color: "blue", children: [
           skippedCount,
           " skipped"
         ] }),
         " \xB7",
         " ",
-        /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+        /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
           failedCount,
           " failed"
         ] })
       ] }),
-      template.backup && !options.skipRestore && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "\u25B8 Proceeding with config file restore..." }),
-        /* @__PURE__ */ jsxs7(Text7, { color: "gray", children: [
+      template.backup && !options.skipRestore && /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Proceeding with config file restore..." }),
+        /* @__PURE__ */ jsxs10(Text10, { color: "gray", children: [
           "  ",
           "Backup link: ",
           template.backup
@@ -1815,8 +2866,8 @@ function registerProvisionCommand(program2) {
       if (tmpl.sudo && !opts.dryRun) {
         ensureSudo(tmpl.name);
       }
-      const { waitUntilExit } = render4(
-        /* @__PURE__ */ jsx7(
+      const { waitUntilExit } = render6(
+        /* @__PURE__ */ jsx10(
           ProvisionView,
           {
             template: tmpl,
@@ -1833,410 +2884,230 @@ function registerProvisionCommand(program2) {
   );
 }
 
-// src/commands/List.tsx
-import { unlinkSync } from "fs";
-import { Box as Box7, Text as Text9, useApp as useApp5, useInput as useInput2 } from "ink";
-import { render as render5 } from "ink";
+// src/commands/Restore.tsx
+import { useState as useState7, useEffect as useEffect6 } from "react";
+import { Text as Text11, Box as Box9, useApp as useApp6 } from "ink";
 import SelectInput2 from "ink-select-input";
-import { useEffect as useEffect5, useState as useState6 } from "react";
-
-// src/components/Table.tsx
-import { Text as Text8, Box as Box6 } from "ink";
-import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
-var Table = ({
-  headers,
-  rows,
-  columnWidths
-}) => {
-  const widths = columnWidths ?? headers.map((header, colIdx) => {
-    const dataMax = rows.reduce(
-      (max, row) => Math.max(max, (row[colIdx] ?? "").length),
-      0
-    );
-    return Math.max(header.length, dataMax) + 2;
-  });
-  const padCell = (text, width) => {
-    return text.padEnd(width);
-  };
-  const separator = widths.map((w) => "\u2500".repeat(w)).join("  ");
-  return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx8(Text8, { children: headers.map((h, i) => /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
-      padCell(h, widths[i]),
-      i < headers.length - 1 ? "  " : ""
-    ] }, i)) }),
-    /* @__PURE__ */ jsx8(Text8, { color: "gray", children: separator }),
-    rows.map((row, rowIdx) => /* @__PURE__ */ jsx8(Text8, { children: row.map((cell, colIdx) => /* @__PURE__ */ jsxs8(Text8, { children: [
-      padCell(cell, widths[colIdx]),
-      colIdx < row.length - 1 ? "  " : ""
-    ] }, colIdx)) }, rowIdx))
-  ] });
-};
-
-// src/commands/List.tsx
-import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
-var MenuItem = ({ isSelected = false, label }) => {
-  if (label === "Delete") {
-    return /* @__PURE__ */ jsx9(Text9, { bold: isSelected, color: "red", children: label });
-  }
-  const match = label.match(/^(.+?)\s+\((\d+)\)$/);
-  if (match) {
-    const [, name, count] = match;
-    return /* @__PURE__ */ jsxs9(Text9, { children: [
-      /* @__PURE__ */ jsx9(Text9, { bold: isSelected, children: name }),
-      " ",
-      /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "(",
-        count,
-        ")"
-      ] })
-    ] });
-  }
-  return /* @__PURE__ */ jsx9(Text9, { bold: isSelected, children: label });
-};
-var ListView = ({ type, deleteIndex }) => {
-  const { exit } = useApp5();
-  const [phase, setPhase] = useState6("loading");
-  const [backups, setBackups] = useState6([]);
-  const [templates, setTemplates] = useState6([]);
-  const [selectedTemplate, setSelectedTemplate] = useState6(
-    null
-  );
-  const [selectedBackup, setSelectedBackup] = useState6(null);
-  const [deleteTarget, setDeleteTarget] = useState6(null);
-  const [error, setError] = useState6(null);
-  useInput2((_input, key) => {
-    if (!key.escape) return;
-    switch (phase) {
-      case "main-menu":
-        exit();
-        break;
-      case "backup-list":
-      case "template-list":
-        setSelectedBackup(null);
-        setSelectedTemplate(null);
-        setPhase("main-menu");
-        break;
-      case "backup-detail":
-        setSelectedBackup(null);
-        setPhase("backup-list");
-        break;
-      case "template-detail":
-        setSelectedTemplate(null);
-        setPhase("template-list");
-        break;
-    }
-  });
-  useEffect5(() => {
-    (async () => {
-      try {
-        const showBackups = !type || type === "backups";
-        const showTemplates = !type || type === "templates";
-        if (showBackups) {
-          const list2 = await getBackupList();
-          setBackups(list2);
-        }
-        if (showTemplates) {
-          const tmpls = await listTemplates();
-          setTemplates(tmpls);
+import { render as render7 } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+var RestoreView = ({ filename, options }) => {
+  const { exit } = useApp6();
+  const [phase, setPhase] = useState7("loading");
+  const [backups, setBackups] = useState7([]);
+  const [selectedPath, setSelectedPath] = useState7(null);
+  const [plan, setPlan] = useState7(null);
+  const [result, setResult] = useState7(null);
+  const [safetyDone, setSafetyDone] = useState7(false);
+  const [error, setError] = useState7(null);
+  useEffect6(() => {
+    (async () => {
+      try {
+        const list2 = await getBackupList();
+        setBackups(list2);
+        if (list2.length === 0) {
+          setError("No backups available.");
+          setPhase("error");
+          exit();
+          return;
         }
-        if (deleteIndex != null && type === "backups") {
-          const list2 = await getBackupList();
-          const idx = deleteIndex - 1;
-          if (idx < 0 || idx >= list2.length) {
-            setError(`Invalid index: ${deleteIndex}`);
+        if (filename) {
+          const match = list2.find(
+            (b) => b.filename === filename || b.filename.startsWith(filename)
+          );
+          if (!match) {
+            setError(`Backup not found: ${filename}`);
             setPhase("error");
-            setTimeout(() => exit(), 100);
+            exit();
             return;
           }
-          setDeleteTarget({
-            name: list2[idx].filename,
-            path: list2[idx].path
-          });
-          setPhase("deleting");
-          return;
+          setSelectedPath(match.path);
+          setPhase("planning");
+        } else {
+          setPhase("selecting");
         }
-        setPhase("main-menu");
       } catch (err) {
         setError(err instanceof Error ? err.message : String(err));
         setPhase("error");
-        setTimeout(() => exit(), 100);
+        exit();
       }
     })();
   }, []);
-  const goBackToMainMenu = () => {
-    setSelectedBackup(null);
-    setSelectedTemplate(null);
-    setPhase("main-menu");
-  };
-  const goBackToBackupList = () => {
-    setSelectedBackup(null);
-    setPhase("backup-list");
-  };
-  const goBackToTemplateList = () => {
-    setSelectedTemplate(null);
-    setPhase("template-list");
-  };
-  const handleDeleteConfirm = (yes) => {
-    if (yes && deleteTarget) {
+  useEffect6(() => {
+    if (phase !== "planning" || !selectedPath) return;
+    (async () => {
       try {
-        if (!isInsideDir(deleteTarget.path, getSubDir("backups"))) {
-          throw new Error(`Refusing to delete file outside backups directory: ${deleteTarget.path}`);
+        const restorePlan = await getRestorePlan(selectedPath);
+        setPlan(restorePlan);
+        if (options.dryRun) {
+          setPhase("done");
+          setTimeout(() => exit(), 100);
+        } else {
+          setPhase("confirming");
         }
-        unlinkSync(deleteTarget.path);
-        setPhase("done");
-        setTimeout(() => exit(), 100);
       } catch (err) {
         setError(err instanceof Error ? err.message : String(err));
         setPhase("error");
-        setTimeout(() => exit(), 100);
+        exit();
       }
-    } else {
-      setDeleteTarget(null);
-      if (selectedBackup) {
-        setPhase("backup-detail");
-      } else {
-        goBackToMainMenu();
+    })();
+  }, [phase, selectedPath]);
+  const handleSelect = (item) => {
+    setSelectedPath(item.value);
+    setPhase("planning");
+  };
+  const handleConfirm = async (yes) => {
+    if (!yes || !selectedPath) {
+      setPhase("done");
+      setTimeout(() => exit(), 100);
+      return;
+    }
+    try {
+      setPhase("restoring");
+      try {
+        const config = await loadConfig();
+        await createBackup(config, { tag: "pre-restore" });
+        setSafetyDone(true);
+      } catch {
       }
+      const restoreResult = await restoreBackup(selectedPath, options);
+      setResult(restoreResult);
+      setPhase("done");
+      setTimeout(() => exit(), 100);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setPhase("error");
+      exit();
     }
   };
   if (phase === "error" || error) {
-    return /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsxs9(Text9, { color: "red", children: [
+    return /* @__PURE__ */ jsx11(Box9, { flexDirection: "column", children: /* @__PURE__ */ jsxs11(Text11, { color: "red", children: [
       "\u2717 ",
       error
     ] }) });
-  }
-  if (phase === "loading") {
-    return /* @__PURE__ */ jsx9(Text9, { color: "cyan", children: "Loading..." });
-  }
-  if (phase === "deleting" && deleteTarget) {
-    return /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx9(
-      Confirm,
-      {
-        message: `Delete ${deleteTarget.name}?`,
-        onConfirm: handleDeleteConfirm,
-        defaultYes: false
-      }
-    ) });
-  }
-  if (phase === "done" && deleteTarget) {
-    return /* @__PURE__ */ jsxs9(Text9, { color: "green", children: [
-      "\u2713 ",
-      deleteTarget.name,
-      " deleted"
-    ] });
-  }
-  if (phase === "main-menu") {
-    const showBackups = !type || type === "backups";
-    const showTemplates = !type || type === "templates";
-    const menuItems = [];
-    if (showBackups) {
-      menuItems.push({
-        label: `Backups (${backups.length})`,
-        value: "backups"
-      });
-    }
-    if (showTemplates) {
-      menuItems.push({
-        label: `Templates (${templates.length})`,
-        value: "templates"
-      });
-    }
-    menuItems.push({ label: "Exit", value: "exit" });
-    const handleMainMenu = (item) => {
-      if (item.value === "exit") {
-        exit();
-      } else if (item.value === "backups") {
-        setPhase("backup-list");
-      } else if (item.value === "templates") {
-        setPhase("template-list");
-      }
-    };
-    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(
-        SelectInput2,
-        {
-          items: menuItems,
-          onSelect: handleMainMenu,
-          itemComponent: MenuItem
-        }
-      ),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "Press ",
-        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
-        " to exit"
-      ] }) })
-    ] });
-  }
-  if (phase === "backup-list") {
-    const items = backups.map((b) => ({
-      label: `${b.filename.replace(".tar.gz", "")}  \u2022  ${formatBytes(b.size)}  \u2022  ${formatDate(b.createdAt)}`,
-      value: b.path
-    }));
-    const handleBackupSelect = (item) => {
-      const backup = backups.find((b) => b.path === item.value);
-      if (backup) {
-        setSelectedBackup(backup);
-        setPhase("backup-detail");
-      }
-    };
-    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(Text9, { bold: true, children: "\u25B8 Backups" }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: backups.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "gray", children: " No backups found." }) : /* @__PURE__ */ jsx9(
-        SelectInput2,
-        {
-          items,
-          onSelect: handleBackupSelect,
-          itemComponent: MenuItem
-        }
-      ) }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "Press ",
-        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
-        " to go back"
-      ] }) })
-    ] });
-  }
-  if (phase === "template-list") {
-    const items = templates.map((t) => ({
-      label: t.config.description ? `${t.config.name}  \u2014  ${t.config.description}` : t.config.name,
-      value: t.path
-    }));
-    const handleTemplateSelect = (item) => {
-      const tmpl = templates.find((t) => t.path === item.value);
-      if (tmpl) {
-        setSelectedTemplate(tmpl);
-        setPhase("template-detail");
-      }
-    };
-    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(Text9, { bold: true, children: "\u25B8 Templates" }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: templates.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "gray", children: " No templates found." }) : /* @__PURE__ */ jsx9(
-        SelectInput2,
-        {
-          items,
-          onSelect: handleTemplateSelect,
-          itemComponent: MenuItem
-        }
-      ) }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "Press ",
-        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
-        " to go back"
-      ] }) })
-    ] });
-  }
-  if (phase === "backup-detail" && selectedBackup) {
-    const sections = [
-      { label: "Filename", value: selectedBackup.filename },
-      { label: "Date", value: formatDate(selectedBackup.createdAt) },
-      { label: "Size", value: formatBytes(selectedBackup.size) },
-      ...selectedBackup.hostname ? [{ label: "Hostname", value: selectedBackup.hostname }] : [],
-      ...selectedBackup.fileCount != null ? [{ label: "Files", value: String(selectedBackup.fileCount) }] : []
-    ];
-    const actionItems = [
-      { label: "Delete", value: "delete" },
-      { label: "Cancel", value: "cancel" }
-    ];
-    const handleDetailAction = (item) => {
-      if (item.value === "delete") {
-        setDeleteTarget({
-          name: selectedBackup.filename,
-          path: selectedBackup.path
-        });
-        setPhase("deleting");
-      } else if (item.value === "cancel") {
-        goBackToBackupList();
-      }
-    };
-    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
-        "\u25B8 ",
-        selectedBackup.filename.replace(".tar.gz", "")
-      ] }),
-      /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => {
-        const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
-        return /* @__PURE__ */ jsxs9(Box7, { children: [
-          /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: section.label.padEnd(labelWidth) }),
-          /* @__PURE__ */ jsx9(Text9, { children: " " }),
-          /* @__PURE__ */ jsx9(Text9, { children: section.value })
-        ] }, idx);
-      }) }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx9(
-        SelectInput2,
-        {
-          items: actionItems,
-          onSelect: handleDetailAction,
-          itemComponent: MenuItem
-        }
-      ) }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "Press ",
-        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
-        " to go back"
-      ] }) })
-    ] });
-  }
-  if (phase === "template-detail" && selectedTemplate) {
-    const t = selectedTemplate.config;
-    const sections = [
-      { label: "Name", value: t.name },
-      ...t.description ? [{ label: "Description", value: t.description }] : [],
-      ...t.backup ? [{ label: "Backup link", value: t.backup }] : [],
-      { label: "Steps", value: String(t.steps.length) }
-    ];
-    const actionItems = [{ label: "Cancel", value: "cancel" }];
-    const handleDetailAction = (item) => {
-      if (item.value === "cancel") {
-        goBackToTemplateList();
-      }
-    };
-    const labelWidth = Math.max(...sections.map((s) => s.label.length)) + 1;
-    return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs9(Text9, { bold: true, children: [
-        "\u25B8 ",
-        selectedTemplate.name
+  }
+  const selectItems = backups.map((b, idx) => ({
+    label: `${String(idx + 1).padStart(2)}  ${b.filename.replace(".tar.gz", "").padEnd(40)}  ${formatBytes(b.size).padStart(8)}   ${formatDate(b.createdAt)}`,
+    value: b.path
+  }));
+  const currentHostname = getHostname();
+  const isRemoteBackup = plan?.metadata.hostname && plan.metadata.hostname !== currentHostname;
+  return /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", children: [
+    phase === "loading" && /* @__PURE__ */ jsx11(Text11, { children: "\u25B8 Loading backup list..." }),
+    phase === "selecting" && /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx11(Text11, { bold: true, children: "\u25B8 Select backup" }),
+      /* @__PURE__ */ jsx11(SelectInput2, { items: selectItems, onSelect: handleSelect })
+    ] }),
+    (phase === "planning" || phase === "confirming" || phase === "restoring" || phase === "done" && plan) && plan && /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs11(Text11, { bold: true, children: [
+          "\u25B8 Metadata (",
+          plan.metadata.config.filename ?? "",
+          ")"
+        ] }),
+        /* @__PURE__ */ jsxs11(Text11, { children: [
+          "  ",
+          "Host: ",
+          plan.metadata.hostname
+        ] }),
+        /* @__PURE__ */ jsxs11(Text11, { children: [
+          "  ",
+          "Created: ",
+          plan.metadata.createdAt
+        ] }),
+        /* @__PURE__ */ jsxs11(Text11, { children: [
+          "  ",
+          "Files: ",
+          plan.metadata.summary.fileCount,
+          " (",
+          formatBytes(plan.metadata.summary.totalSize),
+          ")"
+        ] }),
+        isRemoteBackup && /* @__PURE__ */ jsxs11(Text11, { color: "yellow", children: [
+          "  ",
+          "\u26A0 This backup was created on a different machine (",
+          plan.metadata.hostname,
+          ")"
+        ] })
       ] }),
-      /* @__PURE__ */ jsx9(Box7, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: sections.map((section, idx) => /* @__PURE__ */ jsxs9(Box7, { children: [
-        /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: section.label.padEnd(labelWidth) }),
-        /* @__PURE__ */ jsx9(Text9, { children: " " }),
-        /* @__PURE__ */ jsx9(Text9, { children: section.value })
-      ] }, idx)) }),
-      t.steps.length > 0 && /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: " Provisioning Steps" }),
-        /* @__PURE__ */ jsx9(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx9(
-          Table,
-          {
-            headers: ["#", "Step", "Description"],
-            rows: t.steps.map((s, idx) => [
-              String(idx + 1),
-              s.name,
-              s.description ?? "\u2014"
-            ])
+      /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsx11(Text11, { bold: true, children: "\u25B8 Restore plan:" }),
+        plan.actions.map((action, idx) => {
+          let icon;
+          let color;
+          let label;
+          switch (action.action) {
+            case "overwrite":
+              icon = "Overwrite";
+              color = "yellow";
+              label = `(${formatBytes(action.currentSize ?? 0)} \u2192 ${formatBytes(action.backupSize ?? 0)}, ${action.reason})`;
+              break;
+            case "skip":
+              icon = "Skip";
+              color = "gray";
+              label = `(${action.reason})`;
+              break;
+            case "create":
+              icon = "Create";
+              color = "green";
+              label = "(not present)";
+              break;
           }
-        ) })
+          return /* @__PURE__ */ jsxs11(Text11, { children: [
+            "  ",
+            /* @__PURE__ */ jsx11(Text11, { color, children: icon.padEnd(8) }),
+            "  ",
+            contractTilde(action.path),
+            "  ",
+            /* @__PURE__ */ jsx11(Text11, { color: "gray", children: label })
+          ] }, idx);
+        })
+      ] }),
+      options.dryRun && phase === "done" && /* @__PURE__ */ jsx11(Text11, { color: "yellow", children: "(dry-run) No actual restore was performed" })
+    ] }),
+    phase === "confirming" && /* @__PURE__ */ jsx11(Box9, { flexDirection: "column", children: /* @__PURE__ */ jsx11(Confirm, { message: "Proceed with restore?", onConfirm: handleConfirm }) }),
+    phase === "restoring" && /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", children: [
+      safetyDone && /* @__PURE__ */ jsxs11(Text11, { children: [
+        /* @__PURE__ */ jsx11(Text11, { color: "green", children: "\u2713" }),
+        " Safety backup of current files complete"
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { children: "\u25B8 Restoring..." })
+    ] }),
+    phase === "done" && result && !options.dryRun && /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", marginTop: 1, children: [
+      safetyDone && /* @__PURE__ */ jsxs11(Text11, { children: [
+        /* @__PURE__ */ jsx11(Text11, { color: "green", children: "\u2713" }),
+        " Safety backup of current files complete"
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { color: "green", bold: true, children: "\u2713 Restore complete" }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        "  ",
+        "Restored: ",
+        result.restoredFiles.length,
+        " files"
+      ] }),
+      /* @__PURE__ */ jsxs11(Text11, { children: [
+        "  ",
+        "Skipped: ",
+        result.skippedFiles.length,
+        " files"
       ] }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx9(
-        SelectInput2,
+      result.safetyBackupPath && /* @__PURE__ */ jsxs11(Text11, { children: [
+        "  ",
+        "Safety backup: ",
+        contractTilde(result.safetyBackupPath)
+      ] })
+    ] })
+  ] });
+};
+function registerRestoreCommand(program2) {
+  program2.command("restore [filename]").description("Restore config files from a backup").option("--dry-run", "Show planned changes without actual restore", false).action(async (filename, opts) => {
+    const { waitUntilExit } = render7(
+      /* @__PURE__ */ jsx11(
+        RestoreView,
         {
-          items: actionItems,
-          onSelect: handleDetailAction,
-          itemComponent: MenuItem
+          filename,
+          options: { dryRun: opts.dryRun }
         }
-      ) }),
-      /* @__PURE__ */ jsx9(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
-        "Press ",
-        /* @__PURE__ */ jsx9(Text9, { bold: true, children: "ESC" }),
-        " to go back"
-      ] }) })
-    ] });
-  }
-  return null;
-};
-function registerListCommand(program2) {
-  program2.command("list [type]").description("List backups and templates").option("--delete <n>", "Delete item #n").action(async (type, opts) => {
-    const deleteIndex = opts.delete ? parseInt(opts.delete, 10) : void 0;
-    const { waitUntilExit } = render5(
-      /* @__PURE__ */ jsx9(ListView, { type, deleteIndex })
+      )
     );
     await waitUntilExit();
   });
@@ -2244,12 +3115,12 @@ function registerListCommand(program2) {
 
 // src/commands/Status.tsx
 import { readdirSync, statSync, unlinkSync as unlinkSync2 } from "fs";
-import { join as join11 } from "path";
-import { Box as Box8, Text as Text10, useApp as useApp6, useInput as useInput3 } from "ink";
-import { render as render6 } from "ink";
+import { join as join13 } from "path";
+import { Box as Box10, Text as Text12, useApp as useApp7, useInput as useInput3 } from "ink";
+import { render as render8 } from "ink";
 import SelectInput3 from "ink-select-input";
-import { useEffect as useEffect6, useState as useState7 } from "react";
-import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+import { useEffect as useEffect7, useState as useState8 } from "react";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
 function getDirStats(dirPath) {
   try {
     const entries = readdirSync(dirPath);
@@ -2257,9 +3128,9 @@ function getDirStats(dirPath) {
     let count = 0;
     for (const entry of entries) {
       try {
-        const stat3 = statSync(join11(dirPath, entry));
-        if (stat3.isFile()) {
-          totalSize += stat3.size;
+        const stat4 = statSync(join13(dirPath, entry));
+        if (stat4.isFile()) {
+          totalSize += stat4.size;
           count++;
         }
       } catch {
@@ -2271,33 +3142,34 @@ function getDirStats(dirPath) {
   }
 }
 var DisplayActionItem = ({ isSelected = false, label }) => {
-  return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+  return /* @__PURE__ */ jsx12(Text12, { bold: isSelected, children: label });
 };
 var CleanupActionItem = ({ isSelected = false, label }) => {
   if (label === "Cancel" || label === "Select specific backups to delete") {
-    return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+    return /* @__PURE__ */ jsx12(Text12, { bold: isSelected, children: label });
   }
   const parts = label.split(/\s{2,}/);
   if (parts.length === 2) {
-    return /* @__PURE__ */ jsxs10(Text10, { bold: isSelected, children: [
+    return /* @__PURE__ */ jsxs12(Text12, { bold: isSelected, children: [
       parts[0],
       "  ",
-      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: parts[1] })
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: parts[1] })
     ] });
   }
-  return /* @__PURE__ */ jsx10(Text10, { bold: isSelected, children: label });
+  return /* @__PURE__ */ jsx12(Text12, { bold: isSelected, children: label });
 };
 var StatusView = ({ cleanup }) => {
-  const { exit } = useApp6();
-  const [phase, setPhase] = useState7("loading");
-  const [status, setStatus] = useState7(null);
-  const [backups, setBackups] = useState7([]);
-  const [cleanupAction, setCleanupAction] = useState7(null);
-  const [cleanupMessage, setCleanupMessage] = useState7("");
-  const [error, setError] = useState7(null);
-  const [selectedForDeletion, setSelectedForDeletion] = useState7(
+  const { exit } = useApp7();
+  const [phase, setPhase] = useState8("loading");
+  const [status, setStatus] = useState8(null);
+  const [backups, setBackups] = useState8([]);
+  const [cleanupAction, setCleanupAction] = useState8(null);
+  const [cleanupMessage, setCleanupMessage] = useState8("");
+  const [error, setError] = useState8(null);
+  const [selectedForDeletion, setSelectedForDeletion] = useState8(
     []
   );
+  const [backupDir, setBackupDir] = useState8(getSubDir("backups"));
   useInput3((_input, key) => {
     if (!key.escape) return;
     if (phase === "display") {
@@ -2309,14 +3181,17 @@ var StatusView = ({ cleanup }) => {
       setPhase("cleanup");
     }
   });
-  useEffect6(() => {
+  useEffect7(() => {
     (async () => {
       try {
-        const backupStats = getDirStats(getSubDir("backups"));
+        const config = await loadConfig();
+        const backupDirectory = config.backup.destination ? resolveTargetPath(config.backup.destination) : getSubDir("backups");
+        setBackupDir(backupDirectory);
+        const backupStats = getDirStats(backupDirectory);
         const templateStats = getDirStats(getSubDir("templates"));
         const scriptStats = getDirStats(getSubDir("scripts"));
         const logStats = getDirStats(getSubDir("logs"));
-        const backupList = await getBackupList();
+        const backupList = await getBackupList(config);
         setBackups(backupList);
         const lastBackup = backupList.length > 0 ? backupList[0].createdAt : void 0;
         const oldestBackup = backupList.length > 0 ? backupList[backupList.length - 1].createdAt : void 0;
@@ -2380,11 +3255,10 @@ var StatusView = ({ cleanup }) => {
       return;
     }
     try {
-      const backupsDir = getSubDir("backups");
       if (cleanupAction === "keep-recent-5") {
         const toDelete = backups.slice(5);
         for (const b of toDelete) {
-          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          if (!isInsideDir(b.path, backupDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
           unlinkSync2(b.path);
         }
       } else if (cleanupAction === "older-than-30") {
@@ -2392,7 +3266,7 @@ var StatusView = ({ cleanup }) => {
         cutoff.setDate(cutoff.getDate() - 30);
         const toDelete = backups.filter((b) => b.createdAt < cutoff);
         for (const b of toDelete) {
-          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          if (!isInsideDir(b.path, backupDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
           unlinkSync2(b.path);
         }
       } else if (cleanupAction === "delete-logs") {
@@ -2400,7 +3274,7 @@ var StatusView = ({ cleanup }) => {
         try {
           const entries = readdirSync(logsDir);
           for (const entry of entries) {
-            const logPath = join11(logsDir, entry);
+            const logPath = join13(logsDir, entry);
             if (!isInsideDir(logPath, logsDir)) throw new Error(`Refusing to delete file outside logs directory: ${logPath}`);
             unlinkSync2(logPath);
           }
@@ -2408,7 +3282,7 @@ var StatusView = ({ cleanup }) => {
         }
       } else if (cleanupAction === "select-specific") {
         for (const b of selectedForDeletion) {
-          if (!isInsideDir(b.path, backupsDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
+          if (!isInsideDir(b.path, backupDir)) throw new Error(`Refusing to delete file outside backups directory: ${b.path}`);
           unlinkSync2(b.path);
         }
       }
@@ -2439,26 +3313,26 @@ var StatusView = ({ cleanup }) => {
     }
   };
   if (phase === "error" || error) {
-    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsxs10(Text10, { color: "red", children: [
+    return /* @__PURE__ */ jsx12(Box10, { flexDirection: "column", children: /* @__PURE__ */ jsxs12(Text12, { color: "red", children: [
       "\u2717 ",
       error
     ] }) });
   }
   if (phase === "loading") {
-    return /* @__PURE__ */ jsx10(Text10, { color: "cyan", children: "Loading..." });
+    return /* @__PURE__ */ jsx12(Text12, { color: "cyan", children: "Loading..." });
   }
   if (!status) return null;
   const totalCount = status.backups.count + status.templates.count + status.scripts.count + status.logs.count;
   const totalSize = status.backups.totalSize + status.templates.totalSize + status.scripts.totalSize + status.logs.totalSize;
-  const statusDisplay = /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs10(Text10, { bold: true, children: [
+  const statusDisplay = /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs12(Text12, { bold: true, children: [
       "\u25B8 ",
       APP_NAME,
       " status \u2014 ~/.",
       APP_NAME,
       "/"
     ] }),
-    /* @__PURE__ */ jsx10(Box8, { marginLeft: 2, marginTop: 1, children: /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx12(Box10, { marginLeft: 2, marginTop: 1, children: /* @__PURE__ */ jsx12(
       Table,
       {
         headers: ["Directory", "Count", "Size"],
@@ -2487,15 +3361,15 @@ var StatusView = ({ cleanup }) => {
         ]
       }
     ) }),
-    status.lastBackup && /* @__PURE__ */ jsxs10(Box8, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs10(Text10, { children: [
+    status.lastBackup && /* @__PURE__ */ jsxs12(Box10, { marginTop: 1, marginLeft: 2, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Text12, { children: [
         "Latest backup: ",
         formatDate(status.lastBackup),
         " (",
         formatRelativeTime(status.lastBackup),
         ")"
       ] }),
-      status.oldestBackup && /* @__PURE__ */ jsxs10(Text10, { children: [
+      status.oldestBackup && /* @__PURE__ */ jsxs12(Text12, { children: [
         "Oldest backup: ",
         formatDate(status.oldestBackup),
         " (",
@@ -2504,18 +3378,18 @@ var StatusView = ({ cleanup }) => {
       ] })
     ] })
   ] });
-  const escHint = (action) => /* @__PURE__ */ jsx10(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+  const escHint = (action) => /* @__PURE__ */ jsx12(Box10, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
     "Press ",
-    /* @__PURE__ */ jsx10(Text10, { bold: true, children: "ESC" }),
+    /* @__PURE__ */ jsx12(Text12, { bold: true, children: "ESC" }),
     " to ",
     action
   ] }) });
   if (phase === "display") {
-    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    return /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", children: [
       statusDisplay,
-      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Actions" }),
-        /* @__PURE__ */ jsx10(
+      /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx12(Text12, { bold: true, children: "\u25B8 Actions" }),
+        /* @__PURE__ */ jsx12(
           SelectInput3,
           {
             items: [
@@ -2563,11 +3437,11 @@ var StatusView = ({ cleanup }) => {
         value: "cancel"
       }
     ];
-    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    return /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", children: [
       statusDisplay,
-      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Cleanup options" }),
-        /* @__PURE__ */ jsx10(
+      /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx12(Text12, { bold: true, children: "\u25B8 Cleanup options" }),
+        /* @__PURE__ */ jsx12(
           SelectInput3,
           {
             items: cleanupItems,
@@ -2593,26 +3467,26 @@ var StatusView = ({ cleanup }) => {
         value: "done"
       }
     ];
-    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    return /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", children: [
       statusDisplay,
-      /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", marginTop: 1, children: [
-        /* @__PURE__ */ jsx10(Text10, { bold: true, children: "\u25B8 Select backups to delete" }),
-        selectedForDeletion.length > 0 && /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx12(Text12, { bold: true, children: "\u25B8 Select backups to delete" }),
+        selectedForDeletion.length > 0 && /* @__PURE__ */ jsxs12(Text12, { dimColor: true, children: [
           "  ",
           selectedForDeletion.length,
           " backup(s) selected (",
           formatBytes(selectedForDeletion.reduce((s, b) => s + b.size, 0)),
           ")"
         ] }),
-        /* @__PURE__ */ jsx10(SelectInput3, { items: selectItems, onSelect: handleSelectBackup })
+        /* @__PURE__ */ jsx12(SelectInput3, { items: selectItems, onSelect: handleSelectBackup })
       ] }),
       escHint("go back")
     ] });
   }
   if (phase === "confirming") {
-    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx10(Text10, { children: cleanupMessage }),
-      /* @__PURE__ */ jsx10(
+    return /* @__PURE__ */ jsxs12(Box10, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Text12, { children: cleanupMessage }),
+      /* @__PURE__ */ jsx12(
         Confirm,
         {
           message: "Proceed?",
@@ -2623,28 +3497,464 @@ var StatusView = ({ cleanup }) => {
     ] });
   }
   if (phase === "done") {
-    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsx10(Text10, { color: "green", children: "\u2713 Cleanup complete" }) });
+    return /* @__PURE__ */ jsx12(Box10, { flexDirection: "column", children: /* @__PURE__ */ jsx12(Text12, { color: "green", children: "\u2713 Cleanup complete" }) });
   }
   return null;
 };
 function registerStatusCommand(program2) {
   program2.command("status").description(`Show ~/.${APP_NAME}/ status summary`).option("--cleanup", "Interactive cleanup mode", false).action(async (opts) => {
-    const { waitUntilExit } = render6(/* @__PURE__ */ jsx10(StatusView, { cleanup: opts.cleanup }));
+    const { waitUntilExit } = render8(/* @__PURE__ */ jsx12(StatusView, { cleanup: opts.cleanup }));
     await waitUntilExit();
   });
 }
 
+// src/commands/Wizard.tsx
+import { copyFile as copyFile2, readFile as readFile5, rename, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
+import { join as join15 } from "path";
+import { Box as Box11, Text as Text13, useApp as useApp8 } from "ink";
+import { render as render9 } from "ink";
+import Spinner3 from "ink-spinner";
+import { useEffect as useEffect8, useState as useState9 } from "react";
+
+// src/prompts/wizard-config.ts
+function generateConfigWizardPrompt(variables) {
+  const fileStructureJSON = JSON.stringify(variables.fileStructure, null, 2);
+  return `You are a Syncpoint configuration assistant running in **INTERACTIVE MODE**. Your role is to have a conversation with the user to understand their backup needs, then create a personalized configuration file.
+
+**INTERACTIVE WORKFLOW:**
+1. Analyze the home directory structure provided below
+2. **Ask the user clarifying questions** to understand their backup priorities:
+   - Which development environments do they use? (Node.js, Python, Go, etc.)
+   - Do they want to backup shell customizations? (zsh, bash, fish)
+   - Which application settings are important to them?
+   - Should SSH keys and Git configs be included?
+3. After gathering information, **write the config file directly** using the Write tool
+
+**CRITICAL - File Creation:**
+- **File path**: ~/.syncpoint/config.yml
+- **Use the Write tool** to create this file with the generated YAML
+- After writing the file, confirm to the user that it has been created
+
+**Output Format Requirements:**
+- Pure YAML format only (no markdown, no code blocks, no explanations outside the file)
+- Must be valid according to Syncpoint config schema
+- Include \`backup.targets\` array with recommended files/patterns based on user responses
+- Include \`backup.exclude\` array with common exclusions (node_modules, .git, etc.)
+- Use appropriate pattern types:
+  - Literal paths: ~/.zshrc
+  - Glob patterns: ~/.config/*.conf
+  - Regex patterns: /\\.toml$/ (for scanning with depth limit)
+
+**Home Directory Structure:**
+${fileStructureJSON}
+
+**Default Config Template (for reference):**
+${variables.defaultConfig}
+
+**Start by greeting the user and asking about their backup priorities. After understanding their needs, write the config.yml file directly.**`;
+}
+
+// src/utils/file-scanner.ts
+import { stat as stat3 } from "fs/promises";
+import { join as join14 } from "path";
+import glob from "fast-glob";
+var FILE_CATEGORIES = {
+  shell: {
+    name: "Shell Configuration",
+    patterns: [".zshrc", ".bashrc", ".bash_profile", ".profile", ".zprofile"]
+  },
+  git: {
+    name: "Git Configuration",
+    patterns: [".gitconfig", ".gitignore_global", ".git-credentials"]
+  },
+  ssh: {
+    name: "SSH Configuration",
+    patterns: [".ssh/config", ".ssh/known_hosts"]
+  },
+  editors: {
+    name: "Editor Configuration",
+    patterns: [".vimrc", ".vim/**", ".emacs", ".emacs.d/**"]
+  },
+  terminal: {
+    name: "Terminal & Multiplexer",
+    patterns: [".tmux.conf", ".tmux/**", ".screenrc", ".alacritty.yml"]
+  },
+  appConfigs: {
+    name: "Application Configs",
+    patterns: [
+      ".config/**/*.conf",
+      ".config/**/*.toml",
+      ".config/**/*.yml",
+      ".config/**/*.yaml",
+      ".config/**/*.json"
+    ]
+  },
+  dotfiles: {
+    name: "Other Dotfiles",
+    patterns: [".*rc", ".*profile", ".*.conf"]
+  }
+};
+async function scanHomeDirectory(options) {
+  const homeDir = getHomeDir();
+  const maxDepth = options?.maxDepth ?? 3;
+  const maxFiles = options?.maxFiles ?? 500;
+  const ignorePatterns = options?.ignorePatterns ?? [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/Library/**",
+    "**/Downloads/**",
+    "**/Desktop/**",
+    "**/Documents/**",
+    "**/Pictures/**",
+    "**/Music/**",
+    "**/Videos/**",
+    "**/Movies/**",
+    "**/.Trash/**",
+    "**/.cache/**",
+    "**/.npm/**",
+    "**/.yarn/**",
+    "**/.vscode-server/**",
+    "**/.*_history",
+    "**/.local/share/**"
+  ];
+  const categories = [];
+  const categorizedFiles = /* @__PURE__ */ new Set();
+  let totalFiles = 0;
+  for (const [, category] of Object.entries(FILE_CATEGORIES)) {
+    const patterns = category.patterns;
+    try {
+      const files = await glob(patterns, {
+        ignore: ignorePatterns,
+        dot: true,
+        onlyFiles: true,
+        deep: maxDepth,
+        absolute: false,
+        cwd: homeDir
+      });
+      const validFiles = [];
+      for (const file of files) {
+        try {
+          const fullPath = join14(homeDir, file);
+          await stat3(fullPath);
+          validFiles.push(file);
+          categorizedFiles.add(file);
+        } catch {
+          continue;
+        }
+      }
+      if (validFiles.length > 0) {
+        categories.push({
+          category: category.name,
+          files: validFiles.sort()
+        });
+        totalFiles += validFiles.length;
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (totalFiles < maxFiles) {
+    try {
+      const allFiles = await glob(["**/*", "**/.*"], {
+        ignore: ignorePatterns,
+        dot: true,
+        onlyFiles: true,
+        deep: maxDepth,
+        absolute: false,
+        cwd: homeDir
+      });
+      const uncategorizedFiles = [];
+      for (const file of allFiles) {
+        if (categorizedFiles.has(file)) continue;
+        if (totalFiles >= maxFiles) break;
+        try {
+          const fullPath = join14(homeDir, file);
+          await stat3(fullPath);
+          uncategorizedFiles.push(file);
+          totalFiles++;
+        } catch {
+          continue;
+        }
+      }
+      if (uncategorizedFiles.length > 0) {
+        categories.push({
+          category: "Other Files",
+          files: uncategorizedFiles.sort().slice(0, maxFiles - totalFiles)
+        });
+      }
+    } catch {
+    }
+  }
+  return {
+    homeDir,
+    categories,
+    totalFiles
+  };
+}
+
+// src/commands/Wizard.tsx
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+var MAX_RETRIES2 = 3;
+async function restoreBackup2(configPath) {
+  const bakPath = `${configPath}.bak`;
+  if (await fileExists(bakPath)) {
+    await copyFile2(bakPath, configPath);
+  }
+}
+async function runScanPhase() {
+  const fileStructure = await scanHomeDirectory();
+  const defaultConfig = readAsset("config.default.yml");
+  const prompt = generateConfigWizardPrompt({
+    fileStructure,
+    defaultConfig
+  });
+  return { fileStructure, prompt };
+}
+async function runInteractivePhase(prompt) {
+  console.log("\n\u{1F916} Launching Claude Code in interactive mode...");
+  console.log(
+    "Claude Code will start the conversation automatically. Just respond to the questions!\n"
+  );
+  await invokeClaudeCodeInteractive(prompt);
+}
+async function runValidationPhase(configPath) {
+  try {
+    if (!await fileExists(configPath)) {
+      await restoreBackup2(configPath);
+      console.log("\u26A0\uFE0F  Config file was not created. Restored backup.");
+      return;
+    }
+    const content = await readFile5(configPath, "utf-8");
+    const parsed = parseYAML(content);
+    const validation = validateConfig(parsed);
+    if (!validation.valid) {
+      await restoreBackup2(configPath);
+      console.log(
+        `\u274C Validation failed:
+${formatValidationErrors(validation.errors || [])}`
+      );
+      console.log("Restored previous config from backup.");
+      return;
+    }
+    console.log("\u2705 Config wizard complete! Your config.yml has been created.");
+  } catch (err) {
+    await restoreBackup2(configPath);
+    throw err;
+  }
+}
+var WizardView = ({ printMode }) => {
+  const { exit } = useApp8();
+  const [phase, setPhase] = useState9("init");
+  const [message, setMessage] = useState9("");
+  const [error, setError] = useState9(null);
+  const [prompt, setPrompt] = useState9("");
+  const [sessionId, setSessionId] = useState9(void 0);
+  const [attemptNumber, setAttemptNumber] = useState9(1);
+  useEffect8(() => {
+    (async () => {
+      try {
+        const configPath = join15(getAppDir(), CONFIG_FILENAME);
+        if (await fileExists(configPath)) {
+          setMessage(
+            `Config already exists: ${configPath}
+Would you like to backup and overwrite? (Backup will be saved as config.yml.bak)`
+          );
+          await rename(configPath, `${configPath}.bak`);
+          setMessage(`Backed up existing config to config.yml.bak`);
+        }
+        setPhase("scanning");
+        setMessage("Scanning home directory for backup targets...");
+        const fileStructure = await scanHomeDirectory();
+        setMessage(
+          `Found ${fileStructure.totalFiles} files in ${fileStructure.categories.length} categories`
+        );
+        const defaultConfig = readAsset("config.default.yml");
+        const generatedPrompt = generateConfigWizardPrompt({
+          fileStructure,
+          defaultConfig
+        });
+        setPrompt(generatedPrompt);
+        if (printMode) {
+          setPhase("done");
+          exit();
+          return;
+        }
+        if (!await isClaudeCodeAvailable()) {
+          throw new Error(
+            "Claude Code CLI not found. Install it or use --print mode to get the prompt."
+          );
+        }
+        await invokeLLMWithRetry(generatedPrompt, configPath);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setPhase("error");
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  async function invokeLLMWithRetry(initialPrompt, configPath) {
+    let currentPrompt = initialPrompt;
+    let currentAttempt = 1;
+    let currentSessionId = sessionId;
+    try {
+      while (currentAttempt <= MAX_RETRIES2) {
+        try {
+          setPhase("llm-invoke");
+          setMessage(
+            `Generating config... (Attempt ${currentAttempt}/${MAX_RETRIES2})`
+          );
+          const result = currentSessionId ? await resumeClaudeCodeSession(currentSessionId, currentPrompt) : await invokeClaudeCode(currentPrompt);
+          if (!result.success) {
+            throw new Error(result.error || "Failed to invoke Claude Code");
+          }
+          currentSessionId = result.sessionId;
+          setSessionId(currentSessionId);
+          setPhase("validating");
+          setMessage("Parsing YAML response...");
+          const yamlContent = extractYAML(result.output);
+          if (!yamlContent) {
+            throw new Error("No valid YAML found in LLM response");
+          }
+          const parsedConfig = parseYAML(yamlContent);
+          setMessage("Validating config...");
+          const validation = validateConfig(parsedConfig);
+          if (validation.valid) {
+            setPhase("writing");
+            setMessage("Writing config.yml...");
+            const tmpPath = `${configPath}.tmp`;
+            await writeFile5(tmpPath, yamlContent, "utf-8");
+            const verification = validateConfig(parseYAML(yamlContent));
+            if (verification.valid) {
+              await rename(tmpPath, configPath);
+            } else {
+              await unlink2(tmpPath);
+              throw new Error("Final validation failed");
+            }
+            setPhase("done");
+            setMessage(
+              "\u2713 Config wizard complete! Your config.yml has been created."
+            );
+            setTimeout(() => exit(), 100);
+            return;
+          }
+          if (currentAttempt >= MAX_RETRIES2) {
+            throw new Error(
+              `Validation failed after ${MAX_RETRIES2} attempts:
+${formatValidationErrors(validation.errors || [])}`
+            );
+          }
+          setPhase("retry");
+          setMessage(`Validation failed. Retrying with error context...`);
+          currentPrompt = createRetryPrompt(
+            initialPrompt,
+            validation.errors || [],
+            currentAttempt + 1
+          );
+          currentAttempt++;
+          setAttemptNumber(currentAttempt);
+        } catch (err) {
+          if (currentAttempt >= MAX_RETRIES2) {
+            throw err;
+          }
+          currentAttempt++;
+          setAttemptNumber(currentAttempt);
+        }
+      }
+    } catch (err) {
+      await restoreBackup2(configPath);
+      throw err;
+    }
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", children: /* @__PURE__ */ jsxs13(Text13, { color: "red", children: [
+      "\u2717 ",
+      error
+    ] }) });
+  }
+  if (printMode && phase === "done") {
+    return /* @__PURE__ */ jsxs13(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Text13, { bold: true, children: "Config Wizard Prompt (Copy and paste to your LLM):" }),
+      /* @__PURE__ */ jsx13(Box11, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "\u2500".repeat(60) }) }),
+      /* @__PURE__ */ jsx13(Text13, { children: prompt }),
+      /* @__PURE__ */ jsx13(Box11, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "\u2500".repeat(60) }) }),
+      /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: "After getting the YAML response, save it to ~/.syncpoint/config.yml" })
+    ] });
+  }
+  if (phase === "done") {
+    return /* @__PURE__ */ jsxs13(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "green", children: message }),
+      /* @__PURE__ */ jsxs13(Box11, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx13(Text13, { children: "Next steps:" }),
+        /* @__PURE__ */ jsx13(Text13, { children: " 1. Review your config: ~/.syncpoint/config.yml" }),
+        /* @__PURE__ */ jsx13(Text13, { children: " 2. Run: syncpoint backup" })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs13(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs13(Text13, { children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "cyan", children: /* @__PURE__ */ jsx13(Spinner3, { type: "dots" }) }),
+      " ",
+      message
+    ] }),
+    attemptNumber > 1 && /* @__PURE__ */ jsxs13(Text13, { dimColor: true, children: [
+      "Attempt ",
+      attemptNumber,
+      "/",
+      MAX_RETRIES2
+    ] })
+  ] });
+};
+function registerWizardCommand(program2) {
+  const cmdInfo = COMMANDS.wizard;
+  const cmd = program2.command("wizard").description(cmdInfo.description);
+  cmdInfo.options?.forEach((opt) => {
+    cmd.option(opt.flag, opt.description);
+  });
+  cmd.action(async (opts) => {
+    if (opts.print) {
+      const { waitUntilExit } = render9(/* @__PURE__ */ jsx13(WizardView, { printMode: true }));
+      await waitUntilExit();
+      return;
+    }
+    const configPath = join15(getAppDir(), CONFIG_FILENAME);
+    try {
+      if (await fileExists(configPath)) {
+        console.log(`\u{1F4CB} Backing up existing config to ${configPath}.bak`);
+        await rename(configPath, `${configPath}.bak`);
+      }
+      if (!await isClaudeCodeAvailable()) {
+        throw new Error(
+          "Claude Code CLI not found. Please install it or use --print mode."
+        );
+      }
+      console.log("\u{1F50D} Scanning home directory...");
+      const scanResult = await runScanPhase();
+      console.log(
+        `Found ${scanResult.fileStructure.totalFiles} files in ${scanResult.fileStructure.categories.length} categories`
+      );
+      await runInteractivePhase(scanResult.prompt);
+      await runValidationPhase(configPath);
+    } catch (err) {
+      console.error("\u274C Error:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("syncpoint").description(
   "Personal Environment Manager \u2014 Config backup/restore and machine provisioning CLI"
-).version(APP_VERSION);
+).version(VERSION);
 registerInitCommand(program);
+registerWizardCommand(program);
 registerBackupCommand(program);
 registerRestoreCommand(program);
 registerProvisionCommand(program);
+registerCreateTemplateCommand(program);
 registerListCommand(program);
 registerStatusCommand(program);
+registerHelpCommand(program);
 program.parseAsync(process.argv).catch((error) => {
   console.error("Fatal error:", error.message);
   process.exit(1);