@pushrec/skills 0.2.0 → 0.3.4

package/dist/index.js

@@ -24,7 +24,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander10 = require("commander");
+var import_commander13 = require("commander");
 
 // src/commands/auth.ts
 var import_commander = require("commander");
@@ -114,6 +114,17 @@ async function storeInKeychain(key) {
     }
   } catch {
   }
+  if (os === "win32") {
+    try {
+      (0, import_child_process.execFileSync)(
+        "cmdkey",
+        [`/generic:${KEYCHAIN_SERVICE}`, `/user:${KEYCHAIN_ACCOUNT}`, `/pass:${key}`],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+    } catch {
+    }
+    return false;
+  }
   return false;
 }
 async function retrieveFromKeychain() {
@@ -181,6 +192,16 @@ async function deleteFromKeychain() {
         { stdio: "pipe", timeout: 5e3 }
       );
     }
+    if (os === "win32") {
+      try {
+        (0, import_child_process.execFileSync)(
+          "cmdkey",
+          [`/delete:${KEYCHAIN_SERVICE}`],
+          { stdio: "pipe", timeout: 5e3 }
+        );
+      } catch {
+      }
+    }
   } catch {
   }
 }
@@ -190,7 +211,18 @@ function storeInFile(key) {
     (0, import_fs.mkdirSync)(dir, { recursive: true });
   }
   (0, import_fs.writeFileSync)(CREDENTIALS_FILE, key, "utf-8");
-  (0, import_fs.chmodSync)(CREDENTIALS_FILE, 384);
+  if ((0, import_os2.platform)() !== "win32") {
+    (0, import_fs.chmodSync)(CREDENTIALS_FILE, 384);
+  } else {
+    try {
+      (0, import_child_process.execFileSync)(
+        "icacls",
+        [CREDENTIALS_FILE, "/inheritance:r", "/grant:r", `${process.env.USERNAME}:F`],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+    } catch {
+    }
+  }
 }
 function retrieveFromFile() {
   if (!(0, import_fs.existsSync)(CREDENTIALS_FILE)) return null;
@@ -294,6 +326,8 @@ function getHostname() {
 // src/lib/license.ts
 var ed = __toESM(require("@noble/ed25519"));
 var import_fs3 = require("fs");
+var import_child_process3 = require("child_process");
+var import_os4 = require("os");
 var import_path3 = require("path");
 function fromBase64Url(str) {
   const padded = str.replace(/-/g, "+").replace(/_/g, "/");
@@ -359,7 +393,18 @@ function saveLicenseCache(cache) {
     (0, import_fs3.mkdirSync)(dir, { recursive: true });
   }
   (0, import_fs3.writeFileSync)(LICENSE_CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
-  (0, import_fs3.chmodSync)(LICENSE_CACHE_FILE, 384);
+  if ((0, import_os4.platform)() !== "win32") {
+    (0, import_fs3.chmodSync)(LICENSE_CACHE_FILE, 384);
+  } else {
+    try {
+      (0, import_child_process3.execFileSync)(
+        "icacls",
+        [LICENSE_CACHE_FILE, "/inheritance:r", "/grant:r", `${process.env.USERNAME}:F`],
+        { stdio: "pipe", timeout: 5e3 }
+      );
+    } catch {
+    }
+  }
 }
 function deleteLicenseCache() {
   try {
@@ -399,35 +444,341 @@ function checkOfflineStatus(cache) {
 
 // src/lib/config.ts
 var import_fs4 = require("fs");
+var import_path5 = require("path");
+
+// src/lib/client-roots.ts
+var import_os5 = require("os");
 var import_path4 = require("path");
-function defaultConfig() {
+var SUPPORTED_CLIENTS = [
+  "claude",
+  "codex",
+  "gemini",
+  "antigravity"
+];
+function ctxPlatform(ctx) {
+  return ctx?.platform ?? (0, import_os5.platform)();
+}
+function ctxHome(ctx) {
+  return ctx?.homeDir ?? (0, import_os5.homedir)();
+}
+function ctxEnv(ctx) {
+  return ctx?.env ?? process.env;
+}
+function resolveClaudeHome(ctx) {
+  const env = ctxEnv(ctx);
+  return env.PUSHREC_CLAUDE_HOME || (0, import_path4.join)(ctxHome(ctx), ".claude");
+}
+function resolveCodexHome(ctx) {
+  const env = ctxEnv(ctx);
+  return env.CODEX_HOME || (0, import_path4.join)(ctxHome(ctx), ".codex");
+}
+function resolveGeminiHome(ctx) {
+  const env = ctxEnv(ctx);
+  return env.GEMINI_HOME || (0, import_path4.join)(ctxHome(ctx), ".gemini");
+}
+function resolveAntigravityUserDir(ctx) {
+  const env = ctxEnv(ctx);
+  if (env.PUSHREC_ANTIGRAVITY_USER_DIR) {
+    return env.PUSHREC_ANTIGRAVITY_USER_DIR;
+  }
+  const platform5 = ctxPlatform(ctx);
+  const home = ctxHome(ctx);
+  if (platform5 === "darwin") {
+    return (0, import_path4.join)(home, "Library", "Application Support", "Antigravity", "User");
+  }
+  if (platform5 === "win32") {
+    const appData = env.APPDATA || (0, import_path4.join)(home, "AppData", "Roaming");
+    return (0, import_path4.join)(appData, "Antigravity", "User");
+  }
+  return (0, import_path4.join)(home, ".config", "Antigravity", "User");
+}
+function resolveClientInstallRoots(client, ctx) {
+  const platform5 = ctxPlatform(ctx);
+  switch (client) {
+    case "claude": {
+      const profileHome = resolveClaudeHome(ctx);
+      return {
+        client,
+        platform: platform5,
+        profileHome,
+        skillsRoot: (0, import_path4.join)(profileHome, "skills"),
+        nativeSkillRootVerified: true,
+        previewProfile: false,
+        notes: ["Claude Code native skills root is verified: <CLAUDE_HOME>/skills."]
+      };
+    }
+    case "codex": {
+      const profileHome = resolveCodexHome(ctx);
+      return {
+        client,
+        platform: platform5,
+        profileHome,
+        skillsRoot: (0, import_path4.join)(profileHome, "skills"),
+        nativeSkillRootVerified: true,
+        previewProfile: true,
+        notes: ["Codex native skills root is verified: <CODEX_HOME>/skills."]
+      };
+    }
+    case "gemini": {
+      const profileHome = resolveGeminiHome(ctx);
+      return {
+        client,
+        platform: platform5,
+        profileHome,
+        skillsRoot: null,
+        nativeSkillRootVerified: false,
+        previewProfile: true,
+        notes: [
+          "Gemini preview profile detected, but native skills root is not yet standardized in CLI foundation.",
+          "Use compatibility profile artifacts (e.g., GEMINI.md / commands/extensions) until native root is locked."
+        ]
+      };
+    }
+    case "antigravity": {
+      const profileHome = resolveAntigravityUserDir(ctx);
+      return {
+        client,
+        platform: platform5,
+        profileHome,
+        skillsRoot: null,
+        nativeSkillRootVerified: false,
+        previewProfile: true,
+        notes: [
+          "Antigravity preview profile detected, but native skills root is not yet verified in CLI foundation.",
+          "Use compatibility profile artifacts (AGENTS.md / compatible assets) until native root is locked."
+        ]
+      };
+    }
+    default: {
+      const exhaustive = client;
+      throw new Error(`Unsupported client: ${String(exhaustive)}`);
+    }
+  }
+}
+function getLegacyClaudeSkillsRoot(ctx) {
+  return resolveClientInstallRoots("claude", ctx).skillsRoot;
+}
+
+// src/lib/config.ts
+var CLI_CONFIG_SCHEMA_VERSION = 2;
+function cloneInstalledSkills(skills) {
+  if (!skills) return {};
+  return Object.fromEntries(
+    Object.entries(skills).map(([name, meta]) => [name, { ...meta }])
+  );
+}
+function defaultVaultState() {
+  return {
+    status: "not_started",
+    vaultPath: null,
+    claudeMdPath: null,
+    agentsMdPath: null,
+    lastUpdatedAt: null,
+    backups: []
+  };
+}
+function defaultSetupState() {
+  return {
+    schemaVersion: 1,
+    currentRunId: null,
+    completedPhases: [],
+    lastRunAt: null,
+    lastError: null
+  };
+}
+function emptyClientProfile(client) {
+  const roots = resolveClientInstallRoots(client);
+  return {
+    client,
+    detected: false,
+    selected: false,
+    profileHome: roots.profileHome,
+    skillsRoot: roots.skillsRoot,
+    nativeSkillRootVerified: roots.nativeSkillRootVerified,
+    previewProfile: roots.previewProfile,
+    lastDetectedAt: null,
+    installedSkills: {},
+    notes: [...roots.notes]
+  };
+}
+function defaultClients() {
+  const out = {};
+  for (const client of SUPPORTED_CLIENTS) {
+    out[client] = emptyClientProfile(client);
+  }
+  return out;
+}
+function createDefaultConfig() {
   return {
+    schemaVersion: CLI_CONFIG_SCHEMA_VERSION,
     registryUrl: REGISTRY_URL,
     lastVerifiedAt: null,
-    installedSkills: {}
+    installedSkills: {},
+    clients: defaultClients(),
+    skillState: {},
+    vault: defaultVaultState(),
+    setup: defaultSetupState()
+  };
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function migrateClientProfile(client, rawValue, legacyInstalledSkills) {
+  const base = emptyClientProfile(client);
+  const raw = asRecord(rawValue);
+  if (!raw) {
+    if (client === "claude") {
+      base.installedSkills = cloneInstalledSkills(legacyInstalledSkills);
+    }
+    return base;
+  }
+  return {
+    ...base,
+    detected: typeof raw.detected === "boolean" ? raw.detected : base.detected,
+    selected: typeof raw.selected === "boolean" ? raw.selected : base.selected,
+    profileHome: typeof raw.profileHome === "string" || raw.profileHome === null ? raw.profileHome : base.profileHome,
+    skillsRoot: typeof raw.skillsRoot === "string" || raw.skillsRoot === null ? raw.skillsRoot : base.skillsRoot,
+    nativeSkillRootVerified: typeof raw.nativeSkillRootVerified === "boolean" ? raw.nativeSkillRootVerified : base.nativeSkillRootVerified,
+    previewProfile: typeof raw.previewProfile === "boolean" ? raw.previewProfile : base.previewProfile,
+    lastDetectedAt: typeof raw.lastDetectedAt === "string" || raw.lastDetectedAt === null ? raw.lastDetectedAt : base.lastDetectedAt,
+    installedSkills: cloneInstalledSkills(
+      asRecord(raw.installedSkills)
+    ),
+    notes: Array.isArray(raw.notes) ? raw.notes.filter((x) => typeof x === "string") : base.notes
+  };
+}
+function migrateSkillState(rawValue) {
+  const raw = asRecord(rawValue);
+  if (!raw) return {};
+  const out = {};
+  for (const [name, value] of Object.entries(raw)) {
+    const item = asRecord(value);
+    if (!item) continue;
+    out[name] = {
+      name,
+      mode: item.mode === "managed" || item.mode === "forked" || item.mode === "custom-unmanaged" ? item.mode : "managed",
+      lastKnownVersion: typeof item.lastKnownVersion === "string" || item.lastKnownVersion === null ? item.lastKnownVersion : null,
+      installedPath: typeof item.installedPath === "string" || item.installedPath === null ? item.installedPath : null,
+      targetClient: item.targetClient === "claude" || item.targetClient === "codex" || item.targetClient === "gemini" || item.targetClient === "antigravity" || item.targetClient === null ? item.targetClient : null,
+      contentHash: typeof item.contentHash === "string" || item.contentHash === null ? item.contentHash : null,
+      backups: Array.isArray(item.backups) ? item.backups.filter((x) => typeof x === "string") : [],
+      localModified: typeof item.localModified === "boolean" ? item.localModified : false,
+      lastCheckedAt: typeof item.lastCheckedAt === "string" || item.lastCheckedAt === null ? item.lastCheckedAt : null
+    };
+  }
+  return out;
+}
+function migrateVaultState(rawValue) {
+  const base = defaultVaultState();
+  const raw = asRecord(rawValue);
+  if (!raw) return base;
+  return {
+    status: raw.status === "not_started" || raw.status === "initialized" || raw.status === "adopted" || raw.status === "error" ? raw.status : base.status,
+    vaultPath: typeof raw.vaultPath === "string" || raw.vaultPath === null ? raw.vaultPath : base.vaultPath,
+    claudeMdPath: typeof raw.claudeMdPath === "string" || raw.claudeMdPath === null ? raw.claudeMdPath : base.claudeMdPath,
+    agentsMdPath: typeof raw.agentsMdPath === "string" || raw.agentsMdPath === null ? raw.agentsMdPath : base.agentsMdPath,
+    lastUpdatedAt: typeof raw.lastUpdatedAt === "string" || raw.lastUpdatedAt === null ? raw.lastUpdatedAt : base.lastUpdatedAt,
+    backups: Array.isArray(raw.backups) ? raw.backups.filter((x) => typeof x === "string") : base.backups
+  };
+}
+function migrateSetupState(rawValue) {
+  const base = defaultSetupState();
+  const raw = asRecord(rawValue);
+  if (!raw) return base;
+  return {
+    schemaVersion: typeof raw.schemaVersion === "number" ? raw.schemaVersion : base.schemaVersion,
+    currentRunId: typeof raw.currentRunId === "string" || raw.currentRunId === null ? raw.currentRunId : base.currentRunId,
+    completedPhases: Array.isArray(raw.completedPhases) ? raw.completedPhases.filter((x) => typeof x === "string") : base.completedPhases,
+    lastRunAt: typeof raw.lastRunAt === "string" || raw.lastRunAt === null ? raw.lastRunAt : base.lastRunAt,
+    lastError: typeof raw.lastError === "string" || raw.lastError === null ? raw.lastError : base.lastError
+  };
+}
+function migrateCliConfig(rawValue) {
+  const defaults = createDefaultConfig();
+  const raw = asRecord(rawValue);
+  if (!raw) return defaults;
+  const legacyInstalled = cloneInstalledSkills(
+    asRecord(raw.installedSkills)
+  );
+  const rawClients = asRecord(raw.clients);
+  const clients = {};
+  for (const client of SUPPORTED_CLIENTS) {
+    clients[client] = migrateClientProfile(
+      client,
+      rawClients?.[client],
+      client === "claude" ? legacyInstalled : {}
+    );
+  }
+  return {
+    schemaVersion: CLI_CONFIG_SCHEMA_VERSION,
+    registryUrl: typeof raw.registryUrl === "string" ? raw.registryUrl : REGISTRY_URL,
+    lastVerifiedAt: typeof raw.lastVerifiedAt === "string" || raw.lastVerifiedAt === null ? raw.lastVerifiedAt : null,
+    installedSkills: legacyInstalled,
+    clients,
+    skillState: migrateSkillState(raw.skillState),
+    vault: migrateVaultState(raw.vault),
+    setup: migrateSetupState(raw.setup)
+  };
+}
+function mergeClientProfiles(base, patch) {
+  if (!patch) return base;
+  const out = { ...base };
+  for (const [client, next] of Object.entries(patch)) {
+    if (!next) continue;
+    const key = client;
+    const prev = out[key];
+    out[key] = prev ? {
+      ...prev,
+      ...next,
+      installedSkills: {
+        ...prev.installedSkills,
+        ...next.installedSkills ?? {}
+      },
+      notes: next.notes ?? prev.notes
+    } : next;
+  }
+  return out;
+}
+function mergeCliConfig(current, patch) {
+  return {
+    ...current,
+    ...patch,
+    schemaVersion: CLI_CONFIG_SCHEMA_VERSION,
+    installedSkills: patch.installedSkills ?? current.installedSkills,
+    clients: mergeClientProfiles(current.clients, patch.clients),
+    skillState: { ...current.skillState, ...patch.skillState ?? {} },
+    vault: { ...current.vault, ...patch.vault ?? {} },
+    setup: { ...current.setup, ...patch.setup ?? {} }
   };
 }
 function loadConfig() {
   if (!(0, import_fs4.existsSync)(CONFIG_FILE)) {
-    return defaultConfig();
+    return createDefaultConfig();
   }
   try {
     const raw = (0, import_fs4.readFileSync)(CONFIG_FILE, "utf-8");
-    return { ...defaultConfig(), ...JSON.parse(raw) };
+    return migrateCliConfig(JSON.parse(raw));
   } catch {
-    return defaultConfig();
+    return createDefaultConfig();
   }
 }
 function saveConfig(config) {
-  const dir = (0, import_path4.dirname)(CONFIG_FILE);
+  const dir = (0, import_path5.dirname)(CONFIG_FILE);
   if (!(0, import_fs4.existsSync)(dir)) {
     (0, import_fs4.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_fs4.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  (0, import_fs4.writeFileSync)(
+    CONFIG_FILE,
+    JSON.stringify(migrateCliConfig(config), null, 2),
+    "utf-8"
+  );
 }
 function updateConfig(partial) {
   const config = loadConfig();
-  const updated = { ...config, ...partial };
+  const updated = mergeCliConfig(config, partial);
   saveConfig(updated);
   return updated;
 }
@@ -478,10 +829,11 @@ async function fetchSkillManifest(name) {
   }
   return response.json();
 }
-async function downloadSkill(name) {
+async function downloadSkill(name, version) {
   const authHeaders = await getAuthHeaders();
+  const versionQuery = version ? `?version=${encodeURIComponent(version)}` : "";
   const response = await registryFetch(
-    `/api/skills/${encodeURIComponent(name)}/download`,
+    `/api/skills/${encodeURIComponent(name)}/download${versionQuery}`,
     { headers: authHeaders }
   );
   if (!response.ok) {
@@ -591,17 +943,17 @@ function readInput(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve7, reject) => {
     rl.on("error", (err) => {
       rl.close();
       reject(err);
     });
     rl.on("close", () => {
-      resolve2("");
+      resolve7("");
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve7(answer.trim());
     });
   });
 }
@@ -860,33 +1212,37 @@ var import_ora = __toESM(require("ora"));
 
 // src/lib/installer.ts
 var import_fs5 = require("fs");
-var import_path5 = require("path");
-var import_child_process3 = require("child_process");
-var import_os4 = require("os");
+var import_path6 = require("path");
+var import_child_process4 = require("child_process");
+var import_os6 = require("os");
 var import_crypto2 = require("crypto");
-async function installSkill(name, archive) {
+function resolveSkillsRoot(options) {
+  return options?.skillsRoot ?? getLegacyClaudeSkillsRoot();
+}
+async function installSkill(name, archive, options) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.includes("..")) {
     throw new Error(`Invalid skill name: "${name}"`);
   }
-  const targetDir = (0, import_path5.join)(SKILLS_DIR, name);
+  const skillsRoot = resolveSkillsRoot(options);
+  const targetDir = (0, import_path6.join)(skillsRoot, name);
   const tmpId = (0, import_crypto2.randomBytes)(4).toString("hex");
-  const tmpDir = (0, import_path5.join)((0, import_os4.tmpdir)(), `pushrec-install-${tmpId}`);
+  const tmpDir = (0, import_path6.join)((0, import_os6.tmpdir)(), `pushrec-install-${tmpId}`);
   try {
     (0, import_fs5.mkdirSync)(tmpDir, { recursive: true });
-    const zipPath = (0, import_path5.join)(tmpDir, `${name}.zip`);
+    const zipPath = (0, import_path6.join)(tmpDir, `${name}.zip`);
     (0, import_fs5.writeFileSync)(zipPath, Buffer.from(archive));
-    const extractDir = (0, import_path5.join)(tmpDir, "extracted");
+    const extractDir = (0, import_path6.join)(tmpDir, "extracted");
     (0, import_fs5.mkdirSync)(extractDir, { recursive: true });
     extractZip(zipPath, extractDir);
     const skillRoot = findSkillRoot(extractDir, name);
-    const resolvedRoot = (0, import_path5.resolve)(skillRoot);
-    const resolvedExtract = (0, import_path5.resolve)(extractDir);
-    const rel = (0, import_path5.relative)(resolvedExtract, resolvedRoot);
-    if (rel.startsWith("..") || (0, import_path5.resolve)(rel) === resolvedRoot) {
+    const resolvedRoot = (0, import_path6.resolve)(skillRoot);
+    const resolvedExtract = (0, import_path6.resolve)(extractDir);
+    const rel = (0, import_path6.relative)(resolvedExtract, resolvedRoot);
+    if (rel.startsWith("..") || (0, import_path6.resolve)(rel) === resolvedRoot) {
       throw new Error("Archive contains path traversal \u2014 aborting install.");
     }
-    if (!(0, import_fs5.existsSync)(SKILLS_DIR)) {
-      (0, import_fs5.mkdirSync)(SKILLS_DIR, { recursive: true });
+    if (!(0, import_fs5.existsSync)(skillsRoot)) {
+      (0, import_fs5.mkdirSync)(skillsRoot, { recursive: true });
     }
     if ((0, import_fs5.existsSync)(targetDir)) {
       (0, import_fs5.rmSync)(targetDir, { recursive: true, force: true });
@@ -901,15 +1257,22 @@ async function installSkill(name, archive) {
   }
 }
 function extractZip(zipPath, destDir) {
-  const os = (0, import_os4.platform)();
+  const os = (0, import_os6.platform)();
   if (os === "win32") {
-    (0, import_child_process3.execFileSync)(
+    const safeZip = zipPath.replace(/'/g, "''");
+    const safeDest = destDir.replace(/'/g, "''");
+    (0, import_child_process4.execFileSync)(
       "powershell",
-      ["-NoProfile", "-Command", `Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force`],
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -LiteralPath '${safeZip}' -DestinationPath '${safeDest}' -Force`
+      ],
       { stdio: "pipe", timeout: 6e4 }
     );
   } else {
-    (0, import_child_process3.execFileSync)("unzip", ["-o", "-q", zipPath, "-d", destDir], {
+    (0, import_child_process4.execFileSync)("unzip", ["-o", "-q", zipPath, "-d", destDir], {
       stdio: "pipe",
       timeout: 6e4
     });
@@ -918,36 +1281,311 @@ function extractZip(zipPath, destDir) {
 function findSkillRoot(extractDir, name) {
   const entries = (0, import_fs5.readdirSync)(extractDir);
   const skillDir = entries.find((entry) => {
-    const fullPath = (0, import_path5.join)(extractDir, entry);
+    const fullPath = (0, import_path6.join)(extractDir, entry);
     return (0, import_fs5.statSync)(fullPath).isDirectory() && (entry === name || entry.startsWith(`${name}-`));
   });
   if (skillDir) {
-    return (0, import_path5.join)(extractDir, skillDir);
+    return (0, import_path6.join)(extractDir, skillDir);
   }
   if (entries.includes("SKILL.md")) {
     return extractDir;
   }
   const firstDir = entries.find(
-    (entry) => (0, import_fs5.statSync)((0, import_path5.join)(extractDir, entry)).isDirectory()
+    (entry) => (0, import_fs5.statSync)((0, import_path6.join)(extractDir, entry)).isDirectory()
   );
   if (firstDir) {
-    return (0, import_path5.join)(extractDir, firstDir);
+    return (0, import_path6.join)(extractDir, firstDir);
   }
   throw new Error(
     `Could not find skill root in archive for "${name}". Expected a directory containing SKILL.md.`
   );
 }
-function uninstallSkill(name) {
+function uninstallSkill(name, options) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.includes("..") || name.includes("/") || name.includes("\\")) {
     throw new Error(`Invalid skill name: "${name}". Only lowercase letters, numbers, and hyphens allowed.`);
   }
-  const targetDir = (0, import_path5.join)(SKILLS_DIR, name);
+  const targetDir = (0, import_path6.join)(resolveSkillsRoot(options), name);
   if (!(0, import_fs5.existsSync)(targetDir)) return false;
   (0, import_fs5.rmSync)(targetDir, { recursive: true, force: true });
   return true;
 }
 function isSkillInstalled(name) {
-  return (0, import_fs5.existsSync)((0, import_path5.join)(SKILLS_DIR, name, "SKILL.md"));
+  return isSkillInstalledAtRoot(name, resolveSkillsRoot());
+}
+function getBundledSkillPath(name) {
+  return (0, import_path6.join)(__dirname, "..", "bundled-skills", name);
+}
+function isSkillInstalledAtRoot(name, skillsRoot) {
+  return (0, import_fs5.existsSync)((0, import_path6.join)(skillsRoot, name, "SKILL.md"));
+}
+function copyBundledSkill(name, options) {
+  const sourcePath = options?.bundledSkillPath ?? getBundledSkillPath(name);
+  if (!(0, import_fs5.existsSync)(sourcePath)) return;
+  const skillsRoot = resolveSkillsRoot(options);
+  const targetPath = (0, import_path6.join)(skillsRoot, name);
+  if (!(0, import_fs5.existsSync)(skillsRoot)) {
+    (0, import_fs5.mkdirSync)(skillsRoot, { recursive: true });
+  }
+  if ((0, import_fs5.existsSync)((0, import_path6.join)(targetPath, "SKILL.md"))) return;
+  (0, import_fs5.cpSync)(sourcePath, targetPath, { recursive: true });
+}
+
+// src/lib/managed-skill.ts
+var import_fs8 = require("fs");
+var import_path9 = require("path");
+
+// src/lib/backups.ts
+var import_fs6 = require("fs");
+var import_path7 = require("path");
+var import_crypto3 = require("crypto");
+var DEFAULT_BACKUPS_DIR = (0, import_path7.join)(CONFIG_DIR, "backups");
+function resolveBackupsRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const configured = env.PUSHREC_BACKUPS_DIR?.trim();
+  return (0, import_path7.resolve)(configured && configured.length > 0 ? configured : DEFAULT_BACKUPS_DIR);
+}
+function ensureBackupsRoot(options = {}) {
+  const root = resolveBackupsRoot(options);
+  if (!(0, import_fs6.existsSync)(root)) {
+    (0, import_fs6.mkdirSync)(root, { recursive: true });
+  }
+  return root;
+}
+function sanitizeBackupLabel(label) {
+  const cleaned = label.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return cleaned.length > 0 ? cleaned : "item";
+}
+function createBackupId(prefix, now = /* @__PURE__ */ new Date()) {
+  const ts = now.toISOString().replace(/[:.]/g, "-");
+  const suffix = (0, import_crypto3.randomBytes)(3).toString("hex");
+  return `${sanitizeBackupLabel(prefix)}-${ts}-${suffix}`;
+}
+function buildBackupDirectoryPath(label, options = {}) {
+  const root = resolveBackupsRoot(options);
+  const id = createBackupId(label, options.now);
+  return (0, import_path7.join)(root, id);
+}
+function buildSkillBackupDirectoryPath(skillName, options = {}) {
+  return buildBackupDirectoryPath(`skill-${skillName}`, options);
+}
+
+// src/lib/tree-hash.ts
+var import_crypto4 = require("crypto");
+var import_fs7 = require("fs");
+var import_path8 = require("path");
+function isExcludedName(name, exclude) {
+  return exclude.has(name);
+}
+function walkFiles(root, current, exclude, out) {
+  const entries = (0, import_fs7.readdirSync)(current).sort((a, b) => a.localeCompare(b));
+  for (const entry of entries) {
+    if (isExcludedName(entry, exclude)) continue;
+    const fullPath = (0, import_path8.join)(current, entry);
+    const stat = (0, import_fs7.lstatSync)(fullPath);
+    if (stat.isDirectory()) {
+      walkFiles(root, fullPath, exclude, out);
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    out.push(fullPath);
+  }
+}
+function hashDirectoryTree(rootPath, options = {}) {
+  const root = (0, import_path8.resolve)(rootPath);
+  const stat = (0, import_fs7.lstatSync)(root);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: ${root}`);
+  }
+  const exclude = new Set(options.excludeNames ?? []);
+  const files = [];
+  walkFiles(root, root, exclude, files);
+  const digest = (0, import_crypto4.createHash)("sha256");
+  let totalBytes = 0;
+  for (const file of files) {
+    const rel = (0, import_path8.relative)(root, file).replace(/\\/g, "/");
+    const bytes = (0, import_fs7.readFileSync)(file);
+    totalBytes += bytes.byteLength;
+    digest.update("PATH\0");
+    digest.update(rel);
+    digest.update("\0SIZE\0");
+    digest.update(String(bytes.byteLength));
+    digest.update("\0DATA\0");
+    digest.update(bytes);
+    digest.update("\0END\0");
+  }
+  return {
+    hash: digest.digest("hex"),
+    fileCount: files.length,
+    totalBytes,
+    root
+  };
+}
+
+// src/lib/managed-skill.ts
+var HASH_EXCLUDES = [".DS_Store"];
+var SKILL_BACKUP_METADATA_FILE = ".pushrec-backup.json";
+function resolveInstalledSkillPath(skillName, state) {
+  return state?.installedPath ?? (0, import_path9.join)(getLegacyClaudeSkillsRoot(), skillName);
+}
+function hashInstalledSkillPath(path) {
+  if (!(0, import_fs8.existsSync)(path)) return null;
+  const stat = (0, import_fs8.lstatSync)(path);
+  if (!stat.isDirectory()) return null;
+  return hashDirectoryTree(path, { excludeNames: HASH_EXCLUDES }).hash;
+}
+function isLocalSkillModified(expectedHash, currentHash) {
+  if (!expectedHash || !currentHash) return false;
+  return expectedHash !== currentHash;
+}
+function createSkillBackupSnapshot(skillName, installedPath, metadata) {
+  if (!(0, import_fs8.existsSync)(installedPath)) return null;
+  const stat = (0, import_fs8.lstatSync)(installedPath);
+  if (!stat.isDirectory()) return null;
+  ensureBackupsRoot();
+  const backupPath = buildSkillBackupDirectoryPath(skillName);
+  (0, import_fs8.cpSync)(installedPath, backupPath, { recursive: true });
+  const payload = {
+    skillName,
+    sourceVersion: metadata?.sourceVersion ?? null,
+    sourceHash: metadata?.sourceHash ?? null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_fs8.writeFileSync)(
+    (0, import_path9.join)(backupPath, SKILL_BACKUP_METADATA_FILE),
+    JSON.stringify(payload, null, 2) + "\n",
+    "utf-8"
+  );
+  return backupPath;
+}
+function readSkillBackupMetadata(backupPath) {
+  const metadataPath = (0, import_path9.join)(backupPath, SKILL_BACKUP_METADATA_FILE);
+  if (!(0, import_fs8.existsSync)(metadataPath)) return null;
+  try {
+    const parsed = JSON.parse((0, import_fs8.readFileSync)(metadataPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    return {
+      skillName: typeof parsed.skillName === "string" ? parsed.skillName : "unknown-skill",
+      sourceVersion: typeof parsed.sourceVersion === "string" || parsed.sourceVersion === null ? parsed.sourceVersion : null,
+      sourceHash: typeof parsed.sourceHash === "string" || parsed.sourceHash === null ? parsed.sourceHash : null,
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function buildNextManagedSkillState(params) {
+  const nowIso2 = params.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const previousBackups = params.previous?.backups ?? [];
+  const backups = params.backupPath && !previousBackups.includes(params.backupPath) ? [...previousBackups, params.backupPath] : previousBackups;
+  return {
+    name: params.name,
+    mode: params.previous?.mode ?? "managed",
+    lastKnownVersion: params.version,
+    installedPath: params.installedPath,
+    targetClient: params.targetClient ?? params.previous?.targetClient ?? "claude",
+    contentHash: params.hash ?? params.previous?.contentHash ?? null,
+    backups,
+    localModified: false,
+    lastCheckedAt: nowIso2
+  };
+}
+
+// src/lib/compatibility.ts
+function runtimePlatformFromNodePlatform(platform5) {
+  if (platform5 === "win32") return "windows";
+  if (platform5 === "darwin") return "macos";
+  return "linux";
+}
+function normalizeList(values) {
+  return (values ?? []).map((x) => x.trim().toLowerCase()).filter((x) => x.length > 0);
+}
+function normalizeWindowsStatus(value) {
+  return typeof value === "string" ? value.trim().toUpperCase() : "UNKNOWN";
+}
+function compatibilityOf(skill) {
+  return skill.compatibility ?? null;
+}
+function evaluateSkillCompatibility(skill, options = {}) {
+  const client = options.client ?? "claude";
+  const platform5 = options.platform ?? runtimePlatformFromNodePlatform(process.platform);
+  const compatibility = compatibilityOf(skill);
+  if (!compatibility) {
+    return {
+      allowed: true,
+      requiresOverride: false,
+      status: "ALLOW_WITH_WARNING",
+      reasonCode: "COMPATIBILITY_METADATA_MISSING",
+      message: "Compatibility metadata missing; proceeding in permissive mode for backward compatibility."
+    };
+  }
+  const clients = normalizeList(compatibility.clients);
+  if (clients.length > 0 && !clients.includes(client)) {
+    return {
+      allowed: false,
+      requiresOverride: false,
+      status: "BLOCK_UNSUPPORTED_CLIENT",
+      reasonCode: "UNSUPPORTED_CLIENT",
+      message: `Skill is not marked compatible with client '${client}'.`
+    };
+  }
+  const platforms = normalizeList(compatibility.platforms);
+  if (platforms.length > 0 && !platforms.includes(platform5)) {
+    return {
+      allowed: false,
+      requiresOverride: false,
+      status: "BLOCK_UNSUPPORTED_PLATFORM",
+      reasonCode: "UNSUPPORTED_PLATFORM",
+      message: `Skill is not marked compatible with platform '${platform5}'.`
+    };
+  }
+  if (platform5 === "windows") {
+    const labels = normalizeList(compatibility.labels);
+    const windowsStatus = normalizeWindowsStatus(compatibility.windowsStatus);
+    if (windowsStatus === "INCOMPATIBLE" || windowsStatus === "FAIL") {
+      return {
+        allowed: false,
+        requiresOverride: false,
+        status: "BLOCK_INCOMPATIBLE",
+        reasonCode: "WINDOWS_STATUS_INCOMPATIBLE",
+        message: `Skill is marked Windows-incompatible (${windowsStatus}).`
+      };
+    }
+    if (windowsStatus === "BLOCKED" || windowsStatus === "NOT_RUN") {
+      return {
+        allowed: false,
+        requiresOverride: true,
+        status: "BLOCK_WINDOWS_GATED",
+        reasonCode: "WINDOWS_STATUS_BLOCKED",
+        message: "Skill is Windows-gated (BLOCKED/NOT_RUN). Use explicit override to proceed."
+      };
+    }
+    if (labels.includes("windows-gated")) {
+      return {
+        allowed: false,
+        requiresOverride: true,
+        status: "BLOCK_WINDOWS_GATED",
+        reasonCode: "WINDOWS_GATED_LABEL",
+        message: "Skill is labeled windows-gated. Use explicit override to proceed."
+      };
+    }
+  }
+  return {
+    allowed: true,
+    requiresOverride: false,
+    status: "ALLOW",
+    reasonCode: "ALLOWED",
+    message: "Compatibility check passed."
+  };
+}
+function compatibilitySummary(skill) {
+  const compatibility = compatibilityOf(skill);
+  if (!compatibility) return "unknown";
+  const windowsStatus = compatibility.windowsStatus ? String(compatibility.windowsStatus).toLowerCase() : null;
+  if (windowsStatus) return windowsStatus;
+  const labels = normalizeList(compatibility.labels);
+  if (labels.includes("windows-gated")) return "windows-gated";
+  if (labels.includes("windows-incompatible")) return "windows-incompatible";
+  return "listed";
 }
 
 // src/commands/install.ts
@@ -1031,31 +1669,93 @@ async function ensureLicense(forFreeSkill) {
     return false;
   }
 }
-async function installOne(name, prefix) {
+async function installOne(name, prefix, options) {
   const spinner = (0, import_ora.default)(`${prefix}Fetching ${name}...`).start();
   try {
     const manifest = await fetchSkillManifest(name);
+    const requestedVersion = options.requestedVersion?.trim() || void 0;
+    if (requestedVersion) {
+      const knownVersions = /* @__PURE__ */ new Set([
+        ...manifest.currentVersion ? [manifest.currentVersion] : [],
+        ...manifest.versions.map((v) => v.version)
+      ]);
+      if (!knownVersions.has(requestedVersion)) {
+        spinner.fail(`${prefix}Version ${requestedVersion} is not available for ${name}`);
+        return {
+          ok: false,
+          error: `Version ${requestedVersion} is not available for ${name}`
+        };
+      }
+    }
+    const installVersion = requestedVersion ?? manifest.currentVersion ?? "0.0.0";
+    const compatibility = evaluateSkillCompatibility(manifest, { client: "claude" });
+    if (!compatibility.allowed) {
+      if (compatibility.requiresOverride && options.allowBlocked) {
+        spinner.warn(
+          `${prefix}${name}: compatibility override enabled (${compatibility.reasonCode}); continuing.`
+        );
+      } else {
+        spinner.fail(`${prefix}${name}: ${compatibility.message}`);
+        return {
+          ok: false,
+          error: `${compatibility.reasonCode}: ${compatibility.message}`
+        };
+      }
+    }
     spinner.text = `${prefix}Verifying license...`;
     const licensed = await ensureLicense(manifest.isFree);
     if (!licensed) {
       spinner.fail(`${prefix}License check failed for ${name}`);
       return { ok: false, error: "License check failed" };
     }
-    spinner.text = `${prefix}Downloading ${name} v${manifest.currentVersion ?? "latest"}...`;
-    const archive = await downloadSkill(name);
+    const configBefore = loadConfig();
+    const previousManaged = configBefore.skillState[name];
+    const installedPathBefore = resolveInstalledSkillPath(name, previousManaged);
+    const currentHash = hashInstalledSkillPath(installedPathBefore);
+    const modified = isLocalSkillModified(previousManaged?.contentHash ?? null, currentHash);
+    if (modified && !options.forceReplace) {
+      spinner.fail(`${prefix}Skipped ${name}: local modifications detected (use --force to replace with backup).`);
+      return {
+        ok: false,
+        error: "Local modifications detected. Re-run with --force to back up and replace."
+      };
+    }
+    let backupPath = null;
+    if (options.forceReplace && currentHash) {
+      spinner.text = `${prefix}Creating backup snapshot for ${name}...`;
+      const sourceVersion = configBefore.installedSkills[name]?.version ?? previousManaged?.lastKnownVersion ?? null;
+      backupPath = createSkillBackupSnapshot(name, installedPathBefore, {
+        sourceVersion,
+        sourceHash: currentHash
+      });
+    }
+    spinner.text = `${prefix}Downloading ${name} v${installVersion}...`;
+    const archive = await downloadSkill(name, requestedVersion);
     spinner.text = `${prefix}Installing ${name}...`;
     const { path } = await installSkill(name, archive);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const config = loadConfig();
     config.installedSkills[name] = {
       name,
-      version: manifest.currentVersion ?? "0.0.0",
+      version: installVersion,
       installedAt: config.installedSkills[name]?.installedAt ?? now,
       updatedAt: now
     };
-    updateConfig({ installedSkills: config.installedSkills });
-    spinner.succeed(`${prefix}${name} v${manifest.currentVersion ?? "latest"} installed to ${path}`);
-    return { ok: true, path, version: manifest.currentVersion ?? "latest" };
+    const contentHash = hashInstalledSkillPath(path);
+    const nextManaged = buildNextManagedSkillState({
+      name,
+      version: installVersion,
+      installedPath: path,
+      previous: config.skillState[name],
+      backupPath,
+      hash: contentHash
+    });
+    updateConfig({
+      installedSkills: config.installedSkills,
+      skillState: { [name]: nextManaged }
+    });
+    spinner.succeed(`${prefix}${name} v${installVersion} installed to ${path}`);
+    return { ok: true, path, version: installVersion, backupPath };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     spinner.fail(`${prefix}Failed to install ${name}: ${message}`);
@@ -1063,7 +1763,10 @@ async function installOne(name, prefix) {
   }
 }
 function installCommand() {
-  const cmd = new import_commander2.Command("install").description("Install skill(s) from the Pushrec registry").argument("[name]", "Skill name to install").option("--all", "Install all available skills").option("--force", "Reinstall even if already installed").option("--json", "Output JSON").action(async (name, opts) => {
+  const cmd = new import_commander2.Command("install").description("Install skill(s) from the Pushrec registry").argument("[name]", "Skill name to install").option("--all", "Install all available skills").option("--force", "Reinstall even if already installed (backs up modified installs first)").option("--version <semver>", "Install a specific version (single skill only)").option(
+    "--allow-blocked",
+    "Allow installing compatibility-gated skills (for explicit preview/testing workflows)"
+  ).option("--json", "Output JSON").action(async (name, opts) => {
     if (!name && !opts.all) {
       if (opts.json) {
         console.log(JSON.stringify({ ok: false, error: "Specify a skill name or use --all" }));
@@ -1081,6 +1784,14 @@ function installCommand() {
       console.error("Cannot specify both a skill name and --all.");
       process.exit(1);
     }
+    if (opts.version && opts.all) {
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: "--version can only be used with a single skill name" }));
+        process.exit(1);
+      }
+      console.error("--version can only be used with a single skill name.");
+      process.exit(1);
+    }
     if (name) {
       if (!opts.force && isSkillInstalled(name)) {
         if (opts.json) {
@@ -1090,7 +1801,11 @@ function installCommand() {
         }
         return;
       }
-      const result = await installOne(name, "");
+      const result = await installOne(name, "", {
+        requestedVersion: opts.version,
+        forceReplace: !!opts.force,
+        allowBlocked: !!opts.allowBlocked
+      });
       if (!result.ok) {
         if (opts.json) {
           console.log(JSON.stringify({ ok: false, skill: name, error: result.error }));
@@ -1098,7 +1813,7 @@ function installCommand() {
         process.exit(1);
       }
       if (opts.json) {
-        console.log(JSON.stringify({ ok: true, skill: name, version: result.version, path: result.path }));
+        console.log(JSON.stringify({ ok: true, skill: name, version: result.version, path: result.path, backupPath: result.backupPath ?? null }));
       } else {
         console.log(`
 Done! Use /${name} in your next Claude Code session.`);
@@ -1136,7 +1851,10 @@ Done! Use /${name} in your next Claude Code session.`);
     for (let i = 0; i < toInstall.length; i++) {
       const skill = toInstall[i];
       const prefix = opts.json ? "" : `[${i + 1}/${toInstall.length}] `;
-      const result = await installOne(skill.name, prefix);
+      const result = await installOne(skill.name, prefix, {
+        forceReplace: !!opts.force,
+        allowBlocked: !!opts.allowBlocked
+      });
       results.push({ skill: skill.name, ok: result.ok, version: result.version, error: result.error });
       if (result.ok) {
         installed++;
@@ -1157,125 +1875,235 @@ Done! ${installed} installed, ${failed} failed.`);
 
 // src/commands/update.ts
 var import_commander3 = require("commander");
-async function updateOne(name, currentVersion, prefix, json) {
+async function updateOne(name, currentVersion, prefix, json, forceModified, allowBlocked) {
   try {
     const manifest = await fetchSkillManifest(name);
     const latest = manifest.currentVersion;
+    const compatibility = evaluateSkillCompatibility(manifest, { client: "claude" });
+    if (!compatibility.allowed) {
+      if (!(compatibility.requiresOverride && allowBlocked)) {
+        if (!json) {
+          console.log(`${prefix}Skipped ${name}: ${compatibility.message}`);
+        }
+        return {
+          status: "failed",
+          version: currentVersion,
+          error: `${compatibility.reasonCode}: ${compatibility.message}`
+        };
+      }
+      if (!json) {
+        console.log(
+          `${prefix}${name}: compatibility override enabled (${compatibility.reasonCode}); continuing.`
+        );
+      }
+    }
     if (!latest || latest === currentVersion) {
       if (!json) console.log(`${prefix}${name} is up to date (v${currentVersion}).`);
-      return true;
+      return { status: "up_to_date", version: latest ?? currentVersion };
+    }
+    const preConfig = loadConfig();
+    const previousManaged = preConfig.skillState[name];
+    const installedPathBefore = resolveInstalledSkillPath(name, previousManaged);
+    const currentHash = hashInstalledSkillPath(installedPathBefore);
+    const modified = isLocalSkillModified(previousManaged?.contentHash ?? null, currentHash);
+    if (modified && !forceModified) {
+      if (!json) {
+        console.log(
+          `${prefix}Skipped ${name}: local modifications detected. Re-run with --force-modified to back up and replace.`
+        );
+      }
+      return {
+        status: "skipped_modified",
+        version: currentVersion,
+        error: "Local modifications detected. Re-run with --force-modified to back up and replace."
+      };
+    }
+    let backupPath = null;
+    if (currentHash) {
+      backupPath = createSkillBackupSnapshot(name, installedPathBefore, {
+        sourceVersion: preConfig.installedSkills[name]?.version ?? previousManaged?.lastKnownVersion ?? null,
+        sourceHash: currentHash
+      });
+      if (!json && backupPath) {
+        console.log(`${prefix}Backup snapshot created: ${backupPath}`);
+      }
     }
     if (!json) console.log(`${prefix}Updating ${name} v${currentVersion} -> v${latest}...`);
     const archive = await downloadSkill(name);
-    await installSkill(name, archive);
+    const { path: installedPathAfter } = await installSkill(name, archive);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const config = loadConfig();
     if (config.installedSkills[name]) {
       config.installedSkills[name].version = latest;
       config.installedSkills[name].updatedAt = now;
-      updateConfig({ installedSkills: config.installedSkills });
     }
+    const contentHash = hashInstalledSkillPath(installedPathAfter);
+    const nextManaged = buildNextManagedSkillState({
+      name,
+      version: latest,
+      installedPath: installedPathAfter,
+      previous: config.skillState[name],
+      backupPath,
+      hash: contentHash
+    });
+    updateConfig({
+      installedSkills: config.installedSkills,
+      skillState: { [name]: nextManaged }
+    });
     if (!json) console.log(`${prefix}Updated ${name} to v${latest}.`);
-    return true;
+    return { status: "updated", version: latest, backupPath };
   } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
     if (!json) {
-      console.error(
-        `${prefix}Failed to update ${name}: ${err instanceof Error ? err.message : String(err)}`
-      );
+      console.error(`${prefix}Failed to update ${name}: ${message}`);
     }
-    return false;
+    return { status: "failed", error: message };
   }
 }
 function updateCommand() {
-  const cmd = new import_commander3.Command("update").description("Update installed skills to latest versions").argument("[name]", "Specific skill to update (updates all if omitted)").option("--json", "Output JSON").action(async (name, opts) => {
-    const key = await retrieveLicenseKey();
-    if (key) {
-      const offlineResult = await verifyOffline(key);
-      if (!offlineResult.valid) {
+  const cmd = new import_commander3.Command("update").description("Update installed skills to latest versions").argument("[name]", "Specific skill to update (updates all if omitted)").option(
+    "--force-modified",
+    "Allow replacing locally modified skills (creates backup before overwrite)"
+  ).option(
+    "--allow-blocked",
+    "Allow updating compatibility-gated skills (for explicit preview/testing workflows)"
+  ).option("--json", "Output JSON").action(
+    async (name, opts) => {
+      const key = await retrieveLicenseKey();
+      if (key) {
+        const offlineResult = await verifyOffline(key);
+        if (!offlineResult.valid) {
+          if (opts.json) {
+            console.log(
+              JSON.stringify({
+                ok: false,
+                error: `License invalid: ${offlineResult.error}`
+              })
+            );
+          } else {
+            console.error(`License invalid: ${offlineResult.error}`);
+          }
+          process.exit(1);
+        }
+      }
+      const cache = loadLicenseCache();
+      if (cache && !cache.payload.hasUpdates) {
         if (opts.json) {
-          console.log(JSON.stringify({ ok: false, error: `License invalid: ${offlineResult.error}` }));
+          console.log(
+            JSON.stringify({
+              ok: false,
+              error: "Updates not included in your license. Visit pushrec.com to upgrade."
+            })
+          );
         } else {
-          console.error(`License invalid: ${offlineResult.error}`);
+          console.error(
+            "Updates not included in your license. Visit pushrec.com to upgrade."
+          );
         }
         process.exit(1);
       }
-    }
-    const cache = loadLicenseCache();
-    if (cache && !cache.payload.hasUpdates) {
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: "Updates not included in your license. Visit pushrec.com to upgrade." }));
-      } else {
-        console.error("Updates not included in your license. Visit pushrec.com to upgrade.");
-      }
-      process.exit(1);
-    }
-    const config = loadConfig();
-    const installed = config.installedSkills;
-    if (Object.keys(installed).length === 0) {
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: true, updated: 0, upToDate: 0, failed: 0 }));
-      } else {
-        console.log("No skills installed. Run `pushrec-skills install <name>` first.");
-      }
-      return;
-    }
-    if (name) {
-      const skill = installed[name];
-      if (!skill) {
+      const config = loadConfig();
+      const installed = config.installedSkills;
+      if (Object.keys(installed).length === 0) {
         if (opts.json) {
-          console.log(JSON.stringify({ ok: false, error: `${name} is not installed` }));
+          console.log(
+            JSON.stringify({ ok: true, updated: 0, upToDate: 0, skippedModified: 0, failed: 0 })
+          );
         } else {
-          console.error(`${name} is not installed.`);
+          console.log("No skills installed. Run `pushrec-skills install <name>` first.");
         }
-        process.exit(1);
-      }
-      const ok = await updateOne(name, skill.version, "", !!opts.json);
-      if (opts.json) {
-        console.log(JSON.stringify({ ok, skill: name }));
+        return;
       }
-      if (!ok) process.exit(1);
-      return;
-    }
-    if (!opts.json) console.log("Checking for updates...\n");
-    const entries = Object.entries(installed);
-    let updated = 0;
-    let failed = 0;
-    let upToDate = 0;
-    const results = [];
-    for (let i = 0; i < entries.length; i++) {
-      const [skillName, skill] = entries[i];
-      const prefix = opts.json ? "" : `[${i + 1}/${entries.length}] `;
-      try {
-        const manifest = await fetchSkillManifest(skillName);
-        const latest = manifest.currentVersion;
-        if (!latest || latest === skill.version) {
-          upToDate++;
-          results.push({ skill: skillName, ok: true });
-          continue;
+      if (name) {
+        const skill = installed[name];
+        if (!skill) {
+          if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: `${name} is not installed` }));
+          } else {
+            console.error(`${name} is not installed.`);
+          }
+          process.exit(1);
         }
-        const ok = await updateOne(skillName, skill.version, prefix, !!opts.json);
-        results.push({ skill: skillName, ok });
-        if (ok) {
-          updated++;
-        } else {
-          failed++;
+        const result = await updateOne(
+          name,
+          skill.version,
+          "",
+          !!opts.json,
+          !!opts.forceModified,
+          !!opts.allowBlocked
+        );
+        if (opts.json) {
+          console.log(
+            JSON.stringify({
+              ok: result.status === "updated" || result.status === "up_to_date",
+              skill: name,
+              status: result.status,
+              version: result.version ?? null,
+              backupPath: result.backupPath ?? null,
+              error: result.error
+            })
+          );
         }
-      } catch {
-        if (!opts.json) console.log(`${prefix}${skillName}: could not check for updates.`);
-        results.push({ skill: skillName, ok: false, error: "Could not check for updates" });
-        failed++;
+        if (result.status === "failed" || result.status === "skipped_modified") {
+          process.exit(1);
+        }
+        return;
       }
+      if (!opts.json) console.log("Checking for updates...\n");
+      const entries = Object.entries(installed);
+      let updated = 0;
+      let failed = 0;
+      let upToDate = 0;
+      let skippedModified = 0;
+      const results = [];
+      for (let i = 0; i < entries.length; i++) {
+        const [skillName, skill] = entries[i];
+        const prefix = opts.json ? "" : `[${i + 1}/${entries.length}] `;
+        const result = await updateOne(
+          skillName,
+          skill.version,
+          prefix,
+          !!opts.json,
+          !!opts.forceModified,
+          !!opts.allowBlocked
+        );
+        results.push({
+          skill: skillName,
+          status: result.status,
+          version: result.version,
+          backupPath: result.backupPath,
+          error: result.error
+        });
+        if (result.status === "updated") updated++;
+        if (result.status === "up_to_date") upToDate++;
+        if (result.status === "skipped_modified") skippedModified++;
+        if (result.status === "failed") failed++;
+      }
+      if (opts.json) {
+        console.log(
+          JSON.stringify({
+            ok: failed === 0,
+            updated,
+            upToDate,
+            skippedModified,
+            failed,
+            results
+          })
+        );
+      } else {
+        console.log(
+          `
+Done! ${updated} updated, ${upToDate} up to date, ${skippedModified} skipped (local modifications), ${failed} failed.`
+        );
+        if (skippedModified > 0) {
+          console.log(
+            "Use --force-modified to back up and replace locally modified skills."
+          );
+        }
+      }
+      if (failed > 0) process.exit(1);
     }
-    if (opts.json) {
-      console.log(JSON.stringify({ ok: failed === 0, updated, upToDate, failed, results }));
-    } else {
-      console.log(
-        `
-Done! ${updated} updated, ${upToDate} up to date, ${failed} failed.`
-      );
-    }
-    if (failed > 0) process.exit(1);
-  });
+  );
   return cmd;
 }
 
@@ -1325,14 +2153,14 @@ ${entries.length} skills installed.`);
       return;
     }
     console.log(
-      `${pad("NAME", 30)} ${pad("VERSION", 12)} ${pad("STATUS", 14)} CATEGORY`
+      `${pad("NAME", 30)} ${pad("VERSION", 12)} ${pad("STATUS", 14)} ${pad("COMPAT", 16)} CATEGORY`
     );
-    console.log("-".repeat(78));
+    console.log("-".repeat(98));
     for (const skill of catalog.items) {
       const installed = isSkillInstalled(skill.name);
       const status = skill.isFree ? installed ? "free/installed" : "free" : installed ? "installed" : "available";
       console.log(
-        `${pad(skill.name, 30)} ${pad(skill.currentVersion ?? "-", 12)} ${pad(status, 14)} ${skill.category ?? "-"}`
+        `${pad(skill.name, 30)} ${pad(skill.currentVersion ?? "-", 12)} ${pad(status, 14)} ${pad(compatibilitySummary(skill), 16)} ${skill.category ?? "-"}`
       );
     }
     console.log(`
@@ -1421,6 +2249,11 @@ function infoCommand() {
     console.log(`  Free:       ${manifest.isFree ? "yes" : "no"}`);
     console.log(`  Published:  ${manifest.publishedAt ? manifest.publishedAt.split("T")[0] : "-"}`);
     console.log(`  Installed:  ${installed ? `yes (v${installedInfo?.version ?? "?"})` : "no"}`);
+    console.log(`  Compat:     ${compatibilitySummary(manifest)}`);
+    const compatEval = evaluateSkillCompatibility(manifest, { client: "claude" });
+    if (!compatEval.allowed || compatEval.status === "ALLOW_WITH_WARNING") {
+      console.log(`  CompatNote: ${compatEval.reasonCode} \u2014 ${compatEval.message}`);
+    }
     if (manifest.versions && manifest.versions.length > 0) {
       console.log("");
       console.log("  Versions:");
@@ -1441,7 +2274,7 @@ function infoCommand() {
 var import_commander7 = require("commander");
 var import_chalk2 = __toESM(require("chalk"));
 function createUninstallCommand() {
-  return new import_commander7.Command("uninstall").description("Uninstall a skill from ~/.claude/skills/").argument("<skill-name>", "Name of skill to uninstall").option("--json", "Output JSON").action(async (skillName, opts) => {
+  return new import_commander7.Command("uninstall").description("Uninstall a skill from the active Claude skills root (default ~/.claude/skills/)").argument("<skill-name>", "Name of skill to uninstall").option("--json", "Output JSON").action(async (skillName, opts) => {
     try {
       const removed = uninstallSkill(skillName);
       if (!removed) {
@@ -1471,9 +2304,91 @@ function createUninstallCommand() {
 // src/commands/health.ts
 var import_commander8 = require("commander");
 var import_chalk3 = __toESM(require("chalk"));
-function healthCommand() {
-  const cmd = new import_commander8.Command("health").description("Check registry server health").option("--full", "Run full diagnostic (registry + license + device + skills)").option("--json", "Output as JSON").action(async (opts) => {
-    if (opts.full) {
+
+// src/lib/client-detect.ts
+var import_fs9 = require("fs");
+var import_path10 = require("path");
+function pathExists(path, ctx) {
+  return (ctx?.existsSync ?? import_fs9.existsSync)(path);
+}
+function nowIso(ctx) {
+  return ctx?.nowIso?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+function detectionCandidates(client, roots) {
+  const profileHome = roots.profileHome;
+  if (!profileHome) return [];
+  switch (client) {
+    case "claude":
+      return [
+        (0, import_path10.join)(profileHome, "settings.json"),
+        (0, import_path10.join)(profileHome, "skills"),
+        profileHome
+      ];
+    case "codex":
+      return [
+        (0, import_path10.join)(profileHome, "config.toml"),
+        (0, import_path10.join)(profileHome, "auth.json"),
+        (0, import_path10.join)(profileHome, "version.json"),
+        (0, import_path10.join)(profileHome, "skills"),
+        profileHome
+      ];
+    case "gemini":
+      return [
+        (0, import_path10.join)(profileHome, "installation_id"),
+        (0, import_path10.join)(profileHome, "projects.json"),
+        (0, import_path10.join)(profileHome, "GEMINI.md"),
+        profileHome
+      ];
+    case "antigravity":
+      return [
+        (0, import_path10.join)(profileHome, "settings.json"),
+        (0, import_path10.join)(profileHome, "globalStorage"),
+        profileHome
+      ];
+    default: {
+      const exhaustive = client;
+      throw new Error(`Unsupported client: ${String(exhaustive)}`);
+    }
+  }
+}
+function detectClientProfile(client, ctx) {
+  const roots = resolveClientInstallRoots(client, ctx);
+  const candidates = detectionCandidates(client, roots);
+  const hits = candidates.filter((candidate) => pathExists(candidate, ctx));
+  const detected = hits.length > 0;
+  return {
+    client,
+    detected,
+    selected: detected,
+    profileHome: roots.profileHome,
+    skillsRoot: roots.skillsRoot,
+    nativeSkillRootVerified: roots.nativeSkillRootVerified,
+    previewProfile: roots.previewProfile,
+    lastDetectedAt: detected ? nowIso(ctx) : null,
+    installedSkills: {},
+    notes: [
+      ...roots.notes,
+      ...detected ? [`Detected profile footprint via ${hits[0]}.`] : ["No profile footprint detected on this machine."]
+    ]
+  };
+}
+function detectClientProfiles(ctx) {
+  const profiles = {};
+  const detectedClients = [];
+  for (const client of SUPPORTED_CLIENTS) {
+    const profile = detectClientProfile(client, ctx);
+    profiles[client] = profile;
+    if (profile.detected) {
+      detectedClients.push(client);
+    }
+  }
+  return { profiles, detectedClients };
+}
+
+// src/commands/health.ts
+function healthCommand() {
+  const cmd = new import_commander8.Command("health").description("Check registry server health").option("--full", "Run full diagnostic (registry + license + device + skills)").option("--json", "Output as JSON").action(async (opts) => {
+    if (opts.full) {
       return runFullDiagnostic(opts.json ?? false);
     }
     let response;
@@ -1518,6 +2433,35 @@ function healthCommand() {
   });
   return cmd;
 }
+function pushClientDetectionCheck(checks) {
+  try {
+    const detected = detectClientProfiles();
+    const detectedNames = detected.detectedClients;
+    const detectedCount = detectedNames.length;
+    const previewDetected = detectedNames.filter(
+      (client) => detected.profiles[client]?.previewProfile
+    );
+    const claudeDetected = Boolean(detected.profiles.claude?.detected);
+    let detail = detectedCount > 0 ? `${detectedCount} detected (${detectedNames.join(", ")})` : "No supported local client profiles detected";
+    if (!claudeDetected) {
+      detail += " | Claude Code profile not detected";
+    }
+    if (previewDetected.length > 0) {
+      detail += ` | preview profiles: ${previewDetected.join(", ")}`;
+    }
+    checks.push({
+      name: "Clients",
+      status: detectedCount > 0 ? "pass" : "warn",
+      detail
+    });
+  } catch (err) {
+    checks.push({
+      name: "Clients",
+      status: "warn",
+      detail: `Detection error: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+}
 async function runFullDiagnostic(json) {
   const checks = [];
   try {
@@ -1535,6 +2479,7 @@ async function runFullDiagnostic(json) {
     checks.push({ name: "License", status: "fail", detail: "No license key found. Run: pushrec-skills setup" });
     checks.push({ name: "Device", status: "skip", detail: "Skipped (no license)" });
     checks.push({ name: "Skills", status: "skip", detail: "Skipped (no license)" });
+    pushClientDetectionCheck(checks);
     return printDiagnostic(checks, json);
   }
   const offlineResult = await verifyOffline(key);
@@ -1542,6 +2487,7 @@ async function runFullDiagnostic(json) {
     checks.push({ name: "License", status: "fail", detail: `Invalid signature: ${offlineResult.error}` });
     checks.push({ name: "Device", status: "skip", detail: "Skipped (invalid license)" });
     checks.push({ name: "Skills", status: "skip", detail: "Skipped (invalid license)" });
+    pushClientDetectionCheck(checks);
     return printDiagnostic(checks, json);
   }
   const fingerprint = getMachineFingerprint();
@@ -1580,6 +2526,7 @@ async function runFullDiagnostic(json) {
   } else {
     checks.push({ name: "Skills", status: "warn", detail: "No skills installed. Run: pushrec-skills install --all" });
   }
+  pushClientDetectionCheck(checks);
   printDiagnostic(checks, json);
 }
 function printDiagnostic(checks, json) {
@@ -1609,88 +2556,459 @@ function printDiagnostic(checks, json) {
 }
 
 // src/commands/setup.ts
+var import_fs11 = require("fs");
+var import_path12 = require("path");
 var import_commander9 = require("commander");
 var import_readline2 = require("readline");
 var import_chalk4 = __toESM(require("chalk"));
 var import_ora2 = __toESM(require("ora"));
+
+// src/lib/setup-state.ts
+var import_crypto5 = require("crypto");
+function createSetupRunId(now = /* @__PURE__ */ new Date()) {
+  const ts = now.toISOString().replace(/[:.]/g, "-");
+  const suffix = (0, import_crypto5.randomBytes)(3).toString("hex");
+  return `setup-${ts}-${suffix}`;
+}
+function beginSetupRunState(current, params) {
+  const nowIso2 = params?.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...current,
+    schemaVersion: current.schemaVersion || 1,
+    currentRunId: params?.runId ?? createSetupRunId(new Date(nowIso2)),
+    completedPhases: [],
+    lastRunAt: nowIso2,
+    lastError: null
+  };
+}
+function markSetupPhaseCompletedState(current, phase, params) {
+  const nowIso2 = params?.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const completed = current.completedPhases.includes(phase) ? current.completedPhases : [...current.completedPhases, phase];
+  return {
+    ...current,
+    schemaVersion: current.schemaVersion || 1,
+    completedPhases: completed,
+    lastRunAt: nowIso2
+  };
+}
+function failSetupRunState(current, error, params) {
+  const nowIso2 = params?.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    ...current,
+    schemaVersion: current.schemaVersion || 1,
+    lastRunAt: nowIso2,
+    lastError: error
+  };
+}
+function finishSetupRunState(current, params) {
+  const nowIso2 = params?.nowIso ?? (/* @__PURE__ */ new Date()).toISOString();
+  const withComplete = current.completedPhases.includes("complete") ? current.completedPhases : [...current.completedPhases, "complete"];
+  return {
+    ...current,
+    schemaVersion: current.schemaVersion || 1,
+    currentRunId: null,
+    completedPhases: withComplete,
+    lastRunAt: nowIso2,
+    lastError: null
+  };
+}
+function nextConfigWithSetup(config, setup) {
+  return { ...config, setup };
+}
+function beginSetupRunCheckpoint(params) {
+  const config = loadConfig();
+  const setup = beginSetupRunState(config.setup, params);
+  return updateConfig(nextConfigWithSetup(config, setup));
+}
+function completeSetupPhaseCheckpoint(phase, params) {
+  const config = loadConfig();
+  const setup = markSetupPhaseCompletedState(config.setup, phase, params);
+  return updateConfig(nextConfigWithSetup(config, setup));
+}
+function failSetupRunCheckpoint(error, params) {
+  const config = loadConfig();
+  const setup = failSetupRunState(config.setup, error, params);
+  return updateConfig(nextConfigWithSetup(config, setup));
+}
+function finishSetupRunCheckpoint(params) {
+  const config = loadConfig();
+  const setup = finishSetupRunState(config.setup, params);
+  return updateConfig(nextConfigWithSetup(config, setup));
+}
+
+// src/lib/vault-bootstrap.ts
+var import_fs10 = require("fs");
+var import_path11 = require("path");
+var VAULT_ROOT_FILE_NAMES = ["CLAUDE.md", "AGENTS.md"];
+var DEFAULT_VAULT_DIRECTORIES = [
+  "0-Inbox",
+  "1-Projects",
+  "2-Areas",
+  "3-Resources",
+  "4-Archive",
+  "Daily",
+  "Templates"
+];
+function normalizeMarkdown(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function rootFilePath(vaultPath, name) {
+  return (0, import_path11.join)(vaultPath, name);
+}
+function scanRootFile(vaultPath, name) {
+  const path = rootFilePath(vaultPath, name);
+  if (!(0, import_fs10.existsSync)(path)) {
+    return { name, path, exists: false, sizeBytes: null };
+  }
+  const stat = (0, import_fs10.lstatSync)(path);
+  return {
+    name,
+    path,
+    exists: stat.isFile(),
+    sizeBytes: stat.isFile() ? stat.size : null
+  };
+}
+function scanVaultBootstrapState(vaultPathInput) {
+  const vaultPath = (0, import_path11.resolve)(vaultPathInput);
+  const exists = (0, import_fs10.existsSync)(vaultPath);
+  let isDirectory = false;
+  let isEmptyDirectory = null;
+  let entryNames = [];
+  if (exists) {
+    const stat = (0, import_fs10.lstatSync)(vaultPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`Vault path exists but is not a directory: ${vaultPath}`);
+    }
+    isDirectory = true;
+    entryNames = (0, import_fs10.readdirSync)(vaultPath).sort((a, b) => a.localeCompare(b));
+    isEmptyDirectory = entryNames.length === 0;
+  }
+  const rootFiles = {
+    "CLAUDE.md": scanRootFile(vaultPath, "CLAUDE.md"),
+    "AGENTS.md": scanRootFile(vaultPath, "AGENTS.md")
+  };
+  const requiredDirectories = DEFAULT_VAULT_DIRECTORIES.map((name) => {
+    const path = (0, import_path11.join)(vaultPath, name);
+    return {
+      name,
+      path,
+      exists: (0, import_fs10.existsSync)(path) && (0, import_fs10.lstatSync)(path).isDirectory()
+    };
+  });
+  const recommendedMode = exists && isDirectory && !isEmptyDirectory ? "adopt" : "initialize";
+  return {
+    vaultPath,
+    exists,
+    isDirectory,
+    isEmptyDirectory,
+    entryNames,
+    recommendedMode,
+    rootFiles,
+    requiredDirectories
+  };
+}
+function renderVaultRootFilesFromClaudeSource(claudeSourceContent) {
+  const normalized = normalizeMarkdown(claudeSourceContent);
+  return {
+    claudeMd: normalized,
+    // L3 scaffolding: AGENTS.md mirrors the same source content until client-aware generation lands.
+    agentsMd: normalized
+  };
+}
+function planVaultBootstrap(scan, rendered, options = {}) {
+  const selectedMode = options.modeOverride ?? scan.recommendedMode;
+  if (selectedMode === "adopt" && !scan.exists) {
+    throw new Error(
+      `Vault adopt mode requires an existing directory: ${scan.vaultPath}`
+    );
+  }
+  const createMissingDirectories = options.createMissingDirectories ?? true;
+  const createMissingRootFiles = options.createMissingRootFiles ?? true;
+  const createDirectories = createMissingDirectories ? scan.requiredDirectories.filter((dir) => !dir.exists).map((dir) => dir.path) : [];
+  const rootContentMap = {
+    "CLAUDE.md": rendered.claudeMd,
+    "AGENTS.md": rendered.agentsMd
+  };
+  const createRootFiles = [];
+  const skippedExistingRootFiles = [];
+  for (const name of VAULT_ROOT_FILE_NAMES) {
+    const rootFile = scan.rootFiles[name];
+    if (rootFile.exists) {
+      skippedExistingRootFiles.push({ name, path: rootFile.path, reason: "exists" });
+      continue;
+    }
+    if (!createMissingRootFiles) continue;
+    createRootFiles.push({
+      name,
+      path: rootFile.path,
+      bytes: Buffer.byteLength(rootContentMap[name], "utf-8")
+    });
+  }
+  return {
+    vaultPath: scan.vaultPath,
+    mode: selectedMode,
+    destructive: false,
+    createDirectories,
+    createRootFiles,
+    skippedExistingRootFiles,
+    requiredDirectories: scan.requiredDirectories,
+    rootFiles: scan.rootFiles
+  };
+}
+function applyVaultBootstrapPlan(plan, rendered) {
+  (0, import_fs10.mkdirSync)(plan.vaultPath, { recursive: true });
+  const createdDirectories = [];
+  const createdRootFiles = [];
+  const skippedExistingRootFiles = [...plan.skippedExistingRootFiles.map((x) => x.path)];
+  for (const dir of plan.createDirectories) {
+    if (!(0, import_fs10.existsSync)(dir)) {
+      (0, import_fs10.mkdirSync)(dir, { recursive: true });
+      createdDirectories.push(dir);
+    }
+  }
+  const rootContentMap = {
+    "CLAUDE.md": rendered.claudeMd,
+    "AGENTS.md": rendered.agentsMd
+  };
+  for (const action of plan.createRootFiles) {
+    if ((0, import_fs10.existsSync)(action.path)) {
+      skippedExistingRootFiles.push(action.path);
+      continue;
+    }
+    const content = rootContentMap[action.name];
+    (0, import_fs10.writeFileSync)(action.path, content, "utf-8");
+    createdRootFiles.push(action.path);
+  }
+  return {
+    createdDirectories,
+    createdRootFiles,
+    skippedExistingRootFiles
+  };
+}
+
+// src/commands/setup.ts
+var DEFAULT_VAULT_MODE = "adopt";
+var VALID_VAULT_MODES = /* @__PURE__ */ new Set(["initialize", "adopt", "skip"]);
+var VAULT_MARKERS = [
+  "0-Inbox",
+  "1-Projects",
+  "2-Areas",
+  "3-Resources",
+  "4-Archive",
+  "Daily",
+  "Templates"
+];
+var DEFAULT_CLAUDE_ROOT_TEMPLATE = `# CLAUDE.md
+
+This vault is managed by \`pushrec-skills setup\`.
+
+## Supported Path
+
+- Claude Code is the native launch path for pushREC.
+- Codex, Gemini, and Antigravity are compatibility previews.
+- Windows support is compatibility-gated until native proof evidence is collected.
+
+## Safety Rules
+
+- Do not assume private maintainer paths.
+- Do not overwrite existing root files silently.
+- Keep compatibility labels explicit for non-Claude workflows.
+`;
+function parseVaultMode(input) {
+  const value = (input ?? DEFAULT_VAULT_MODE).toLowerCase();
+  if (!VALID_VAULT_MODES.has(value)) {
+    throw new Error(
+      `Invalid --vault-mode: ${input}. Expected one of: initialize, adopt, skip.`
+    );
+  }
+  return value;
+}
+function hasVaultMarkerLayout(path) {
+  let present = 0;
+  for (const marker of VAULT_MARKERS) {
+    if ((0, import_fs11.existsSync)((0, import_path12.join)(path, marker))) {
+      present++;
+    }
+  }
+  return present >= 3 && (0, import_fs11.existsSync)((0, import_path12.join)(path, "1-Projects"));
+}
+function resolveVaultPath(mode, optionPath) {
+  if (mode === "skip") {
+    return { path: null, source: "skip" };
+  }
+  if (optionPath) {
+    return { path: (0, import_path12.resolve)(optionPath), source: "--vault-path" };
+  }
+  const envPath = process.env.PUSHREC_VAULT_PATH;
+  if (envPath) {
+    return { path: (0, import_path12.resolve)(envPath), source: "PUSHREC_VAULT_PATH" };
+  }
+  const cwd = process.cwd();
+  if (hasVaultMarkerLayout(cwd)) {
+    return { path: (0, import_path12.resolve)(cwd), source: "cwd-detected" };
+  }
+  throw new Error(
+    "Vault path is ambiguous. Pass --vault-path <absolute-or-relative-path> or set PUSHREC_VAULT_PATH."
+  );
+}
+function validateVaultPath(mode, vaultPath) {
+  if (mode !== "adopt") return;
+  if (!(0, import_fs11.existsSync)(vaultPath)) {
+    throw new Error(
+      `Vault adopt mode requires an existing directory: ${vaultPath}`
+    );
+  }
+  const stat = (0, import_fs11.lstatSync)(vaultPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Vault path is not a directory: ${vaultPath}`);
+  }
+}
+function resolveClaudeTemplateSource() {
+  const override = process.env.PUSHREC_CLAUDE_TEMPLATE;
+  if (override?.trim()) {
+    return override;
+  }
+  return DEFAULT_CLAUDE_ROOT_TEMPLATE;
+}
 function readInput2(question) {
   const rl = (0, import_readline2.createInterface)({
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve7, reject) => {
     rl.on("error", (err) => {
       rl.close();
       reject(err);
     });
     rl.on("close", () => {
-      resolve2("");
+      resolve7("");
     });
     rl.question(question, (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve7(answer.trim());
     });
   });
 }
 function setupCommand() {
-  const cmd = new import_commander9.Command("setup").description("One-command onboarding: verify license, activate device, install all skills").option("--key <license-key>", "License key (or enter interactively)").option("--json", "Output JSON").action(async (opts) => {
-    const existing = await retrieveLicenseKey();
-    if (existing) {
+  const cmd = new import_commander9.Command("setup").description("One-command onboarding: verify license, activate device, install all skills").option("--key <license-key>", "License key (or enter interactively)").option(
+    "--vault-mode <mode>",
+    "Vault bootstrap mode: initialize, adopt, or skip (default: adopt)",
+    DEFAULT_VAULT_MODE
+  ).option("--vault-path <path>", "Vault path for bootstrap/adopt").option(
+    "--allow-blocked",
+    "Allow installing compatibility-gated skills during setup (preview/testing only)"
+  ).option("--json", "Output JSON").action(async (opts) => {
+    let setupRunStarted = false;
+    let existing = "";
+    let detectedClients = [];
+    let vaultSummary = {
+      mode: DEFAULT_VAULT_MODE,
+      status: "SKIPPED",
+      vaultPath: null,
+      pathSource: "skip",
+      recommendedMode: null,
+      createdDirectories: [],
+      createdRootFiles: [],
+      skippedExistingRootFiles: []
+    };
+    const recordSetupFailure = (error) => {
+      if (!setupRunStarted) return;
+      try {
+        failSetupRunCheckpoint(error);
+      } catch {
+      }
+    };
+    const failAndExit = (error) => {
+      recordSetupFailure(error);
       if (opts.json) {
-        console.log(JSON.stringify({ ok: true, message: "Already set up" }));
+        console.log(JSON.stringify({ ok: false, error }));
       } else {
-        console.log(import_chalk4.default.green("Already set up!") + " Run " + import_chalk4.default.cyan("pushrec-skills auth status") + " to check your license.");
-        console.log("To re-setup, run " + import_chalk4.default.cyan("pushrec-skills auth logout") + " first.");
+        console.error(error);
       }
-      return;
+      process.exit(1);
+    };
+    const checkpointPhase = (phase) => {
+      try {
+        completeSetupPhaseCheckpoint(phase);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        failAndExit(`Failed to persist setup checkpoint (${phase}): ${message}`);
+      }
+    };
+    let selectedVaultMode = DEFAULT_VAULT_MODE;
+    try {
+      selectedVaultMode = parseVaultMode(opts.vaultMode);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      failAndExit(message);
+    }
+    vaultSummary.mode = selectedVaultMode;
+    try {
+      beginSetupRunCheckpoint();
+      setupRunStarted = true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: `Failed to initialize setup state: ${message}` }));
+      } else {
+        console.error(`Failed to initialize setup state: ${message}`);
+      }
+      process.exit(1);
+    }
+    try {
+      existing = await retrieveLicenseKey() ?? "";
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      failAndExit(`Failed to read existing license key: ${message}`);
     }
     if (!opts.json) {
       console.log("");
       console.log(import_chalk4.default.bold("Pushrec Skills Setup"));
       console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       console.log("");
+      if (existing) {
+        console.log(import_chalk4.default.dim("Existing license found in keychain \u2014 re-running setup to verify, reactivate, and sync installs."));
+        console.log("");
+      }
     }
-    const key = opts.key ?? await readInput2("Paste your license key: ");
+    const key = (opts.key ?? existing) || await readInput2("Paste your license key: ");
     if (!key) {
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: "No license key provided" }));
-      } else {
-        console.error("No license key provided.");
-      }
-      process.exit(1);
+      failAndExit("No license key provided");
     }
+    checkpointPhase("license_input");
     const verifySpinner = opts.json ? null : (0, import_ora2.default)("Verifying license signature...").start();
-    const offlineResult = await verifyOffline(key);
+    const offlineResult = await verifyOffline(key).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      verifySpinner?.fail(`Could not verify license signature: ${message}`);
+      return failAndExit(`Could not verify license signature: ${message}`);
+    });
     if (!offlineResult.valid) {
       verifySpinner?.fail(`Invalid license key: ${offlineResult.error}`);
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: `Invalid license key: ${offlineResult.error}` }));
-      }
-      process.exit(1);
+      failAndExit(`Invalid license key: ${offlineResult.error}`);
     }
     verifySpinner?.succeed("License signature valid");
+    checkpointPhase("offline_verify");
     const onlineSpinner = opts.json ? null : (0, import_ora2.default)("Checking with server...").start();
     const fingerprint = getMachineFingerprint();
-    let onlineResult;
-    try {
-      onlineResult = await verifyLicenseOnline(key, fingerprint);
-    } catch (err) {
+    const onlineResult = await verifyLicenseOnline(key, fingerprint).catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       onlineSpinner?.fail(`Could not reach server: ${message}`);
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: `Could not reach server: ${message}` }));
-      }
-      process.exit(1);
-    }
+      return failAndExit(`Could not reach server: ${message}`);
+    });
     if (!onlineResult.valid) {
       onlineSpinner?.fail(`License rejected: ${onlineResult.error}`);
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: `License rejected: ${onlineResult.error}` }));
-      }
-      process.exit(1);
+      failAndExit(`License rejected: ${onlineResult.error}`);
     }
     onlineSpinner?.succeed("Server confirmed license active");
-    await storeLicenseKey(key);
+    checkpointPhase("online_verify");
+    try {
+      await storeLicenseKey(key);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      failAndExit(`Failed to store license key: ${message}`);
+    }
+    checkpointPhase("store_license");
     const deviceSpinner = opts.json ? null : (0, import_ora2.default)("Activating this device...").start();
     let activation;
     try {
@@ -1700,15 +3018,15 @@ function setupCommand() {
         getPlatformName(),
         getHostname()
       );
-      deviceSpinner?.succeed(`Device activated (${activation.deviceCount}/${activation.maxDevices} slots used)`);
+      const deviceCount = activation.deviceCount ?? onlineResult.deviceCount ?? 1;
+      const maxDevices = activation.maxDevices ?? onlineResult.maxDevices ?? 3;
+      deviceSpinner?.succeed(`Device activated (${deviceCount}/${maxDevices} slots used)`);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       deviceSpinner?.fail(`Device activation failed: ${message}`);
-      if (opts.json) {
-        console.log(JSON.stringify({ ok: false, error: `Device activation failed: ${message}` }));
-      }
-      process.exit(1);
+      failAndExit(`Device activation failed: ${message}`);
     }
+    checkpointPhase("activate_device");
     const cache = {
       verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
       expiresAt: onlineResult.updatesExpireAt ?? null,
@@ -1722,7 +3040,75 @@ function setupCommand() {
         deviceCount: onlineResult.deviceCount ?? 1
       }
     };
-    saveLicenseCache(cache);
+    try {
+      saveLicenseCache(cache);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      failAndExit(`Failed to save license cache: ${message}`);
+    }
+    checkpointPhase("cache_verification");
+    try {
+      const detected = detectClientProfiles();
+      detectedClients = detected.detectedClients;
+      updateConfig({ clients: detected.profiles });
+    } catch {
+    }
+    checkpointPhase("detect_clients");
+    if (selectedVaultMode !== "skip") {
+      let resolvedVaultPath = null;
+      try {
+        const resolved = resolveVaultPath(selectedVaultMode, opts.vaultPath);
+        resolvedVaultPath = resolved.path;
+        vaultSummary.pathSource = resolved.source;
+        vaultSummary.vaultPath = resolved.path;
+        checkpointPhase("resolve_vault");
+        if (!resolved.path) {
+          throw new Error("Resolved vault path is empty for non-skip mode.");
+        }
+        validateVaultPath(selectedVaultMode, resolved.path);
+        const scan = scanVaultBootstrapState(resolved.path);
+        const rendered = renderVaultRootFilesFromClaudeSource(resolveClaudeTemplateSource());
+        const vaultModeForBootstrap = selectedVaultMode === "adopt" ? "adopt" : "initialize";
+        const plan = planVaultBootstrap(scan, rendered, {
+          modeOverride: vaultModeForBootstrap
+        });
+        vaultSummary.recommendedMode = scan.recommendedMode;
+        checkpointPhase("plan_vault_bootstrap");
+        const applyResult = applyVaultBootstrapPlan(plan, rendered);
+        checkpointPhase("apply_vault_bootstrap");
+        const vaultStatus = plan.mode === "adopt" ? "adopted" : "initialized";
+        const previousVaultState = loadConfig().vault;
+        const updatedVaultState = updateConfig({
+          vault: {
+            ...previousVaultState,
+            status: vaultStatus,
+            vaultPath: plan.vaultPath,
+            claudeMdPath: (0, import_path12.join)(plan.vaultPath, "CLAUDE.md"),
+            agentsMdPath: (0, import_path12.join)(plan.vaultPath, "AGENTS.md"),
+            lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }).vault;
+        vaultSummary.status = plan.mode === "adopt" ? "ADOPTED" : "INITIALIZED";
+        vaultSummary.createdDirectories = applyResult.createdDirectories;
+        vaultSummary.createdRootFiles = applyResult.createdRootFiles;
+        vaultSummary.skippedExistingRootFiles = applyResult.skippedExistingRootFiles;
+        vaultSummary.vaultPath = updatedVaultState.vaultPath;
+      } catch (err) {
+        if (resolvedVaultPath) {
+          const previousVaultState = loadConfig().vault;
+          updateConfig({
+            vault: {
+              ...previousVaultState,
+              status: "error",
+              vaultPath: resolvedVaultPath,
+              lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        failAndExit(`Vault bootstrap failed: ${message}`);
+      }
+    }
     if (!opts.json) {
       console.log("");
       console.log(import_chalk4.default.bold("Installing skills..."));
@@ -1732,34 +3118,70 @@ function setupCommand() {
       catalog = await fetchSkillCatalog();
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      recordSetupFailure(`Could not fetch catalog: ${message}`);
       if (opts.json) {
-        console.log(JSON.stringify({ ok: true, activated: true, installed: 0, error: `Could not fetch catalog: ${message}` }));
+        console.log(
+          JSON.stringify({
+            ok: true,
+            activated: true,
+            installed: 0,
+            error: `Could not fetch catalog: ${message}`,
+            detectedClients,
+            vault: vaultSummary
+          })
+        );
       } else {
         console.error(`Could not fetch catalog: ${message}`);
         console.log(import_chalk4.default.yellow("License activated but skill install failed. Run ") + import_chalk4.default.cyan("pushrec-skills install --all") + import_chalk4.default.yellow(" to retry."));
       }
       return;
     }
+    checkpointPhase("fetch_catalog");
     const toInstall = catalog.items.filter((s) => !isSkillInstalled(s.name));
     let installed = 0;
     let failed = 0;
+    let blocked = 0;
     for (let i = 0; i < toInstall.length; i++) {
       const skill = toInstall[i];
       const prefix = opts.json ? "" : `[${i + 1}/${toInstall.length}] `;
       const spinner = opts.json ? null : (0, import_ora2.default)(`${prefix}Installing ${skill.name}...`).start();
       try {
         const manifest = await fetchSkillManifest(skill.name);
+        const compatibility = evaluateSkillCompatibility(manifest, { client: "claude" });
+        if (!compatibility.allowed) {
+          if (compatibility.requiresOverride && opts.allowBlocked) {
+            spinner?.warn(
+              `${prefix}${skill.name}: compatibility override enabled (${compatibility.reasonCode}); continuing.`
+            );
+          } else {
+            spinner?.fail(`${prefix}Skipped ${skill.name}: ${compatibility.message}`);
+            blocked++;
+            continue;
+          }
+        }
         const archive = await downloadSkill(skill.name);
         const { path } = await installSkill(skill.name, archive);
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const config = loadConfig();
+        const installedVersion = manifest.currentVersion ?? "0.0.0";
         config.installedSkills[skill.name] = {
           name: skill.name,
-          version: manifest.currentVersion ?? "0.0.0",
+          version: installedVersion,
           installedAt: config.installedSkills[skill.name]?.installedAt ?? now,
           updatedAt: now
         };
-        updateConfig({ installedSkills: config.installedSkills });
+        const contentHash = hashInstalledSkillPath(path);
+        const nextManaged = buildNextManagedSkillState({
+          name: skill.name,
+          version: installedVersion,
+          installedPath: path,
+          previous: config.skillState[skill.name],
+          hash: contentHash
+        });
+        updateConfig({
+          installedSkills: config.installedSkills,
+          skillState: { [skill.name]: nextManaged }
+        });
         spinner?.succeed(`${prefix}${skill.name} v${manifest.currentVersion ?? "latest"} installed to ${path}`);
         installed++;
       } catch (err) {
@@ -1768,35 +3190,870 @@ function setupCommand() {
         failed++;
       }
     }
+    checkpointPhase("install_skills");
+    try {
+      copyBundledSkill("pushrec-skills");
+    } catch {
+    }
+    checkpointPhase("copy_bundled_skill");
     const skipped = catalog.items.length - toInstall.length;
+    try {
+      finishSetupRunCheckpoint();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!opts.json) {
+        console.log(import_chalk4.default.yellow(`Warning: setup completed but failed to persist final setup checkpoint: ${message}`));
+      }
+    }
     if (opts.json) {
-      console.log(JSON.stringify({
-        ok: true,
-        activated: true,
-        installed,
-        failed,
-        skipped,
-        total: catalog.items.length
-      }));
+      console.log(
+        JSON.stringify({
+          ok: true,
+          activated: true,
+          installed,
+          blocked,
+          failed,
+          skipped,
+          total: catalog.items.length,
+          detectedClients,
+          vault: vaultSummary
+        })
+      );
     } else {
       console.log("");
-      console.log(import_chalk4.default.green.bold("Setup complete!"));
-      console.log(`  ${import_chalk4.default.green("+")} ${installed} skills installed`);
-      if (skipped > 0) console.log(`  ${import_chalk4.default.dim("-")} ${skipped} already installed`);
-      if (failed > 0) console.log(`  ${import_chalk4.default.red("x")} ${failed} failed`);
+      console.log(import_chalk4.default.green("  Setup complete!"));
+      console.log(`    ${import_chalk4.default.green("+")} ${installed} skills installed`);
+      if (blocked > 0) console.log(`    ${import_chalk4.default.yellow("!")} ${blocked} compatibility-gated/skipped`);
+      if (skipped > 0) console.log(`    ${import_chalk4.default.dim("-")} ${skipped} already installed`);
+      if (failed > 0) console.log(`    ${import_chalk4.default.red("x")} ${failed} failed`);
+      if (selectedVaultMode === "skip") {
+        console.log(`    ${import_chalk4.default.dim("-")} Vault bootstrap skipped (--vault-mode skip)`);
+      } else {
+        const vaultStatusLabel = vaultSummary.status === "INITIALIZED" ? "initialized" : "adopted";
+        console.log(
+          `    ${import_chalk4.default.green("+")} Vault ${vaultStatusLabel} at ${vaultSummary.vaultPath ?? "(unknown path)"}`
+        );
+        console.log(
+          `      created dirs: ${vaultSummary.createdDirectories.length}, root files: ${vaultSummary.createdRootFiles.length}, skipped root files: ${vaultSummary.skippedExistingRootFiles.length}`
+        );
+      }
+      console.log("");
+      console.log(`  ${import_chalk4.default.bold("NEXT STEP:")} Open Claude Code and type ${import_chalk4.default.cyan("/pushrec-skills")}`);
+      console.log("");
+      console.log("  Quick reference:");
+      console.log(`    ${import_chalk4.default.cyan("/pushrec-skills")}       \u2014 Your guided setup (start here)`);
+      console.log(`    ${import_chalk4.default.cyan("/hormozi")}              \u2014 Business strategy frameworks`);
+      console.log(`    ${import_chalk4.default.cyan("/linkedin-copywriting")} \u2014 LinkedIn content creation`);
+      console.log(`    ${import_chalk4.default.cyan("/copywriting")}          \u2014 Master copywriting foundations`);
       console.log("");
-      console.log("Your skills are ready. Use " + import_chalk4.default.cyan("/<skill-name>") + " in your next Claude Code session.");
-      console.log("Run " + import_chalk4.default.cyan("pushrec-skills health --full") + " to verify everything works.");
+      if (detectedClients.length > 0) {
+        console.log(`  Detected local clients: ${detectedClients.join(", ")} ${import_chalk4.default.dim("(Claude-first install is active; preview client setup comes next)")}`);
+        console.log("");
+      }
+      console.log(`  Community: ${import_chalk4.default.underline("skool.com/pushrec-2909")}`);
+      console.log(`  Full catalog: ${import_chalk4.default.dim("npx @pushrec/skills list")}`);
     }
   });
   return cmd;
 }
 
+// src/commands/dashboard.ts
+var import_commander10 = require("commander");
+var import_http = require("http");
+var import_fs12 = require("fs");
+var import_path13 = require("path");
+var import_os7 = require("os");
+var import_child_process5 = require("child_process");
+var DEFAULT_PORT = 5174;
+function getPushrecSkillDir() {
+  return (0, import_path13.join)(getLegacyClaudeSkillsRoot(), "pushrec-skills");
+}
+function getDataSources() {
+  const pushrecSkillDir = getPushrecSkillDir();
+  return {
+    "/api/config": CONFIG_FILE,
+    "/api/profile": (0, import_path13.join)(pushrecSkillDir, "state", "profile.json"),
+    "/api/progress": (0, import_path13.join)(pushrecSkillDir, "state", "progress.json"),
+    "/api/catalog": (0, import_path13.join)(pushrecSkillDir, "state", "catalog.json"),
+    "/api/diagnostic": (0, import_path13.join)(pushrecSkillDir, "state", "diagnostic.json"),
+    "/api/teams": (0, import_path13.join)(pushrecSkillDir, "state", "teams.json"),
+    "/api/tasks": (0, import_path13.join)(pushrecSkillDir, "state", "tasks.json")
+  };
+}
+function getYamlSources() {
+  const pushrecSkillDir = getPushrecSkillDir();
+  return {
+    "/api/prerequisites": (0, import_path13.join)(
+      pushrecSkillDir,
+      "references",
+      "prerequisites.yaml"
+    )
+  };
+}
+function expandPath(filepath) {
+  if (filepath.startsWith("~/")) {
+    return (0, import_path13.join)((0, import_os7.homedir)(), filepath.slice(2));
+  }
+  return filepath;
+}
+function serveJson(res, data) {
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.end(data);
+}
+function serveError(res, status, message) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify({ error: message }));
+}
+function parseYaml(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { raw };
+  }
+}
+function handleApiRequest(req, res) {
+  const url = req.url ?? "";
+  const dataSources = getDataSources();
+  const yamlSources = getYamlSources();
+  if (url === "/api/mtime") {
+    const mtimes = {};
+    for (const [endpoint, filepath] of Object.entries(dataSources)) {
+      try {
+        mtimes[endpoint] = (0, import_fs12.statSync)(expandPath(filepath)).mtimeMs;
+      } catch {
+        mtimes[endpoint] = 0;
+      }
+    }
+    for (const [endpoint, filepath] of Object.entries(yamlSources)) {
+      try {
+        mtimes[endpoint] = (0, import_fs12.statSync)(expandPath(filepath)).mtimeMs;
+      } catch {
+        mtimes[endpoint] = 0;
+      }
+    }
+    serveJson(res, JSON.stringify(mtimes));
+    return true;
+  }
+  if (url in dataSources) {
+    const filepath = dataSources[url];
+    const resolved = expandPath(filepath);
+    try {
+      const data = (0, import_fs12.readFileSync)(resolved, "utf-8");
+      serveJson(res, data);
+    } catch {
+      serveError(res, 500, `Failed to read ${filepath}`);
+    }
+    return true;
+  }
+  if (url in yamlSources) {
+    const filepath = yamlSources[url];
+    const resolved = expandPath(filepath);
+    try {
+      const raw = (0, import_fs12.readFileSync)(resolved, "utf-8");
+      const data = parseYaml(raw);
+      serveJson(res, JSON.stringify(data));
+    } catch {
+      serveError(res, 500, `Failed to read ${filepath}`);
+    }
+    return true;
+  }
+  return false;
+}
+function findDistDirectory() {
+  const candidates = [
+    (0, import_path13.join)(getLegacyClaudeSkillsRoot(), "generative-ui", "dist"),
+    (0, import_path13.join)((0, import_os7.homedir)(), ".cache", "genui-dashboard", "dist")
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_fs12.existsSync)((0, import_path13.join)(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function serveStatic(distDir, req, res) {
+  let urlPath = (req.url ?? "/").split("?")[0];
+  if (urlPath === "/") urlPath = "/index.html";
+  const filePath = (0, import_path13.join)(distDir, urlPath);
+  if (!filePath.startsWith(distDir)) {
+    serveError(res, 403, "Forbidden");
+    return;
+  }
+  try {
+    const content = (0, import_fs12.readFileSync)(filePath);
+    const ext = filePath.split(".").pop() ?? "";
+    const mimeTypes = {
+      html: "text/html",
+      js: "application/javascript",
+      css: "text/css",
+      json: "application/json",
+      png: "image/png",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      woff2: "font/woff2",
+      woff: "font/woff"
+    };
+    res.setHeader("Content-Type", mimeTypes[ext] ?? "application/octet-stream");
+    res.end(content);
+  } catch {
+    try {
+      const indexContent = (0, import_fs12.readFileSync)((0, import_path13.join)(distDir, "index.html"));
+      res.setHeader("Content-Type", "text/html");
+      res.end(indexContent);
+    } catch {
+      serveError(res, 404, "Not found");
+    }
+  }
+}
+function openBrowser(url) {
+  const platform5 = process.platform;
+  const command = platform5 === "darwin" ? `open "${url}"` : platform5 === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+  (0, import_child_process5.exec)(command, () => {
+  });
+}
+function dashboardCommand() {
+  const cmd = new import_commander10.Command("dashboard").description("Launch the Generative UI dashboard").option("--port <port>", "Server port", String(DEFAULT_PORT)).option("--dev", "Start in dev mode with Vite HMR").option("--no-open", "Skip opening browser").action(
+    async (opts) => {
+      const port = parseInt(opts.port, 10);
+      if (isNaN(port) || port < 1024 || port > 65535) {
+        console.error(
+          `ERROR: Port must be between 1024 and 65535, got "${opts.port}".`
+        );
+        process.exit(1);
+      }
+      if (opts.dev) {
+        console.log("Dev mode is not yet supported via CLI.");
+        console.log(
+          "Use the Vite dev server directly: cd dashboard && npm run dev"
+        );
+        process.exit(0);
+      }
+      const distDir = findDistDirectory();
+      if (!distDir) {
+        console.error("ERROR: No built dashboard found.");
+        console.error(
+          "  Build the dashboard first, or use --dev mode."
+        );
+        console.error(
+          `  Expected: ${(0, import_path13.join)(getLegacyClaudeSkillsRoot(), "generative-ui", "dist", "index.html")}`
+        );
+        process.exit(1);
+      }
+      const server = (0, import_http.createServer)((req, res) => {
+        if (req.url?.startsWith("/api/")) {
+          const handled = handleApiRequest(req, res);
+          if (handled) return;
+        }
+        serveStatic(distDir, req, res);
+      });
+      server.listen(port, () => {
+        const url = `http://localhost:${port}`;
+        console.log(`Dashboard running at ${url}`);
+        console.log(`  Serving: ${distDir}`);
+        console.log(`  Press Ctrl+C to stop`);
+        console.log();
+        if (opts.open !== false) {
+          openBrowser(url);
+        }
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          console.error(`ERROR: Port ${port} is already in use.`);
+          console.error(
+            "  Stop the process currently using this port with your platform's process tools, then retry."
+          );
+        } else {
+          console.error(`ERROR: ${err.message}`);
+        }
+        process.exit(1);
+      });
+      const shutdown = () => {
+        console.log("\nShutting down dashboard...");
+        server.close(() => {
+          process.exit(0);
+        });
+        setTimeout(() => process.exit(0), 3e3);
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+      if (process.platform === "win32") {
+        process.on("SIGBREAK", shutdown);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/commands/rollback.ts
+var import_fs13 = require("fs");
+var import_path14 = require("path");
+var import_commander11 = require("commander");
+function resolveBackupSelection(backups, selector) {
+  if (backups.length === 0) {
+    throw new Error("No backups recorded for this skill.");
+  }
+  if (!selector) {
+    return backups[backups.length - 1];
+  }
+  if (backups.includes(selector)) {
+    return selector;
+  }
+  const matches = backups.filter((path) => {
+    const base = (0, import_path14.basename)(path);
+    return base.includes(selector) || path.endsWith(selector);
+  });
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `Backup selector '${selector}' is ambiguous. Matches: ${matches.join(", ")}`
+    );
+  }
+  throw new Error(`Backup '${selector}' not found in recorded backups.`);
+}
+function restoreBackupDirectory(backupPath, installedPath) {
+  if (!(0, import_fs13.existsSync)(backupPath) || !(0, import_fs13.lstatSync)(backupPath).isDirectory()) {
+    throw new Error(`Backup directory does not exist: ${backupPath}`);
+  }
+  (0, import_fs13.mkdirSync)((0, import_path14.dirname)(installedPath), { recursive: true });
+  (0, import_fs13.rmSync)(installedPath, { recursive: true, force: true });
+  (0, import_fs13.cpSync)(backupPath, installedPath, { recursive: true });
+  const metadataInTarget = (0, import_path14.join)(installedPath, SKILL_BACKUP_METADATA_FILE);
+  if ((0, import_fs13.existsSync)(metadataInTarget)) {
+    (0, import_fs13.rmSync)(metadataInTarget, { force: true });
+  }
+}
+function rollbackCommand() {
+  const cmd = new import_commander11.Command("rollback").description("Rollback an installed skill to a backup snapshot").argument("<name>", "Skill name to rollback").option("--backup-id <id>", "Backup id/path selector (defaults to latest)").option("--json", "Output JSON").action(async (name, opts) => {
+    const config = loadConfig();
+    const managed = config.skillState[name];
+    if (!managed) {
+      const error = `${name} has no managed state; rollback unavailable.`;
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error }));
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    let selectedBackup;
+    try {
+      selectedBackup = resolveBackupSelection(managed.backups, opts.backupId);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error }));
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    const installedPath = resolveInstalledSkillPath(name, managed);
+    const existingHash = hashInstalledSkillPath(installedPath);
+    let preRollbackBackup = null;
+    if (existingHash) {
+      preRollbackBackup = createSkillBackupSnapshot(name, installedPath, {
+        sourceVersion: config.installedSkills[name]?.version ?? managed.lastKnownVersion ?? null,
+        sourceHash: existingHash
+      });
+    }
+    try {
+      restoreBackupDirectory(selectedBackup, installedPath);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error }));
+      } else {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    const restoredHash = hashInstalledSkillPath(installedPath);
+    const backupMetadata = readSkillBackupMetadata(selectedBackup);
+    const restoredVersion = backupMetadata?.sourceVersion ?? managed.lastKnownVersion ?? config.installedSkills[name]?.version ?? "unknown";
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const nextInstalled = {
+      ...config.installedSkills[name] ?? {
+        name,
+        version: restoredVersion,
+        installedAt: now,
+        updatedAt: now
+      },
+      name,
+      version: restoredVersion,
+      updatedAt: now
+    };
+    const nextManaged = buildNextManagedSkillState({
+      name,
+      version: restoredVersion,
+      installedPath,
+      previous: managed,
+      backupPath: preRollbackBackup,
+      hash: restoredHash
+    });
+    updateConfig({
+      installedSkills: {
+        [name]: nextInstalled
+      },
+      skillState: {
+        [name]: nextManaged
+      }
+    });
+    if (opts.json) {
+      console.log(
+        JSON.stringify({
+          ok: true,
+          skill: name,
+          restoredFrom: selectedBackup,
+          restoredVersion,
+          installedPath,
+          preRollbackBackup
+        })
+      );
+      return;
+    }
+    console.log(`Rolled back ${name}.`);
+    console.log(`  restoredFrom: ${selectedBackup}`);
+    console.log(`  restoredVersion: ${restoredVersion}`);
+    console.log(`  installedPath: ${installedPath}`);
+    if (preRollbackBackup) {
+      console.log(`  preRollbackBackup: ${preRollbackBackup}`);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/sync.ts
+var import_commander12 = require("commander");
+var import_ora3 = __toESM(require("ora"));
+function resolveSyncTargets(name, catalogNames, installedNames, updatesOnly) {
+  if (name) {
+    return { mode: "single", targets: [name] };
+  }
+  if (updatesOnly) {
+    return { mode: "bulk", targets: installedNames.sort((a, b) => a.localeCompare(b)) };
+  }
+  return { mode: "bulk", targets: [...catalogNames].sort((a, b) => a.localeCompare(b)) };
+}
+var SKIP_EXIT_BLOCKING_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "skipped_compatibility",
+  "skipped_modified"
+]);
+var LicenseGate = class {
+  paidAllowed = null;
+  async ensure(forFreeSkill) {
+    if (forFreeSkill) return true;
+    if (this.paidAllowed !== null) return this.paidAllowed;
+    const key = await retrieveLicenseKey();
+    if (!key) {
+      this.paidAllowed = false;
+      return false;
+    }
+    const offlineResult = await verifyOffline(key);
+    if (!offlineResult.valid) {
+      this.paidAllowed = false;
+      return false;
+    }
+    const cache = loadLicenseCache();
+    if (cache) {
+      const status = checkOfflineStatus(cache);
+      if (status.status === "disabled") {
+        this.paidAllowed = false;
+        return false;
+      }
+      if (status.status === "stale" || status.status === "warning") {
+        try {
+          const fresh = await verifyLicenseOnline(key, getMachineFingerprint());
+          if (!fresh.valid) {
+            this.paidAllowed = false;
+            return false;
+          }
+          const refreshed = {
+            ...cache,
+            verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            expiresAt: fresh.updatesExpireAt ?? null,
+            payload: {
+              buyerId: fresh.buyerId ?? cache.payload.buyerId,
+              email: fresh.email ?? cache.payload.email,
+              maxDevices: fresh.maxDevices ?? cache.payload.maxDevices,
+              status: fresh.status ?? cache.payload.status,
+              hasUpdates: fresh.hasUpdates ?? cache.payload.hasUpdates,
+              deviceCount: fresh.deviceCount ?? cache.payload.deviceCount
+            }
+          };
+          saveLicenseCache(refreshed);
+        } catch {
+        }
+      }
+      this.paidAllowed = true;
+      return true;
+    }
+    try {
+      const fresh = await verifyLicenseOnline(key, getMachineFingerprint());
+      this.paidAllowed = !!fresh.valid;
+      return this.paidAllowed;
+    } catch {
+      this.paidAllowed = false;
+      return false;
+    }
+  }
+};
+async function syncOneSkill(name, opts) {
+  const spinner = opts.json ? null : (0, import_ora3.default)(`Syncing ${name}...`).start();
+  const fail = (status, reasonCode, message, fromVersion) => {
+    spinner?.fail(`${name}: ${message}`);
+    return { skill: name, status, reasonCode, message, fromVersion: fromVersion ?? null };
+  };
+  try {
+    const config = loadConfig();
+    const installed = config.installedSkills[name];
+    const installedVersion = installed?.version ?? null;
+    if (!installed && opts.updatesOnly) {
+      spinner?.info(`${name}: not installed locally (updates-only mode).`);
+      return {
+        skill: name,
+        status: "skipped_not_installed",
+        reasonCode: "UPDATES_ONLY",
+        message: "Skill is not installed and --updates-only is enabled."
+      };
+    }
+    const manifest = await fetchSkillManifest(name).catch((err) => {
+      throw new Error(`manifest-fetch:${err instanceof Error ? err.message : String(err)}`);
+    });
+    const compatibility = evaluateSkillCompatibility(manifest, { client: "claude" });
+    if (!compatibility.allowed) {
+      if (!(compatibility.requiresOverride && opts.allowBlocked)) {
+        return fail(
+          "skipped_compatibility",
+          "COMPATIBILITY_BLOCKED",
+          `${compatibility.reasonCode}: ${compatibility.message}`,
+          installedVersion
+        );
+      }
+      spinner?.warn(
+        `${name}: compatibility override enabled (${compatibility.reasonCode}); continuing.`
+      );
+    }
+    const licensed = await opts.licenseGate.ensure(manifest.isFree);
+    if (!licensed) {
+      return fail(
+        "failed",
+        installed ? "UPDATE_FAILED" : "INSTALL_FAILED",
+        "License validation failed for paid skill operation.",
+        installedVersion
+      );
+    }
+    if (!installed) {
+      const targetVersion = manifest.currentVersion ?? "0.0.0";
+      const archive2 = await downloadSkill(name);
+      const { path: path2 } = await installSkill(name, archive2);
+      const now2 = (/* @__PURE__ */ new Date()).toISOString();
+      const after = loadConfig();
+      const nextInstalled2 = {
+        ...after.installedSkills,
+        [name]: {
+          name,
+          version: targetVersion,
+          installedAt: now2,
+          updatedAt: now2
+        }
+      };
+      const contentHash2 = hashInstalledSkillPath(path2);
+      const nextManaged2 = buildNextManagedSkillState({
+        name,
+        version: targetVersion,
+        installedPath: path2,
+        previous: after.skillState[name],
+        hash: contentHash2
+      });
+      updateConfig({
+        installedSkills: nextInstalled2,
+        skillState: { [name]: nextManaged2 }
+      });
+      spinner?.succeed(`${name}: installed v${targetVersion}.`);
+      return {
+        skill: name,
+        status: "installed",
+        fromVersion: null,
+        toVersion: targetVersion,
+        installedPath: path2
+      };
+    }
+    const latest = manifest.currentVersion;
+    if (!latest || latest === installedVersion) {
+      spinner?.succeed(`${name}: already up to date (${installedVersion ?? "-"})`);
+      return {
+        skill: name,
+        status: "up_to_date",
+        fromVersion: installedVersion,
+        toVersion: latest ?? installedVersion
+      };
+    }
+    const previousManaged = config.skillState[name];
+    const installedPathBefore = resolveInstalledSkillPath(name, previousManaged);
+    const currentHash = hashInstalledSkillPath(installedPathBefore);
+    const modified = isLocalSkillModified(previousManaged?.contentHash ?? null, currentHash);
+    if (modified && !opts.forceModified) {
+      return fail(
+        "skipped_modified",
+        "LOCAL_MODIFIED",
+        "Local modifications detected. Re-run with --force-modified to back up and replace.",
+        installedVersion
+      );
+    }
+    let backupPath = null;
+    if (currentHash) {
+      backupPath = createSkillBackupSnapshot(name, installedPathBefore, {
+        sourceVersion: installedVersion,
+        sourceHash: currentHash
+      });
+    }
+    const archive = await downloadSkill(name);
+    const { path } = await installSkill(name, archive);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const refreshed = loadConfig();
+    const nextInstalled = {
+      ...refreshed.installedSkills,
+      [name]: {
+        name,
+        version: latest,
+        installedAt: refreshed.installedSkills[name]?.installedAt ?? now,
+        updatedAt: now
+      }
+    };
+    const contentHash = hashInstalledSkillPath(path);
+    const nextManaged = buildNextManagedSkillState({
+      name,
+      version: latest,
+      installedPath: path,
+      previous: refreshed.skillState[name],
+      backupPath,
+      hash: contentHash
+    });
+    updateConfig({
+      installedSkills: nextInstalled,
+      skillState: { [name]: nextManaged }
+    });
+    spinner?.succeed(`${name}: updated ${installedVersion ?? "-"} -> ${latest}.`);
+    return {
+      skill: name,
+      status: "updated",
+      fromVersion: installedVersion,
+      toVersion: latest,
+      backupPath,
+      installedPath: path
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.startsWith("manifest-fetch:")) {
+      return fail(
+        "failed",
+        "MANIFEST_FETCH_FAILED",
+        message.replace("manifest-fetch:", "")
+      );
+    }
+    return fail(
+      "failed",
+      "INSTALL_FAILED",
+      message
+    );
+  }
+}
+function syncCommand() {
+  const cmd = new import_commander12.Command("sync").description(
+    "Synchronize local skills with the registry (install missing + update installed)"
+  ).argument("[name]", "Optional single skill name to sync").option(
+    "--updates-only",
+    "Only update already-installed skills (skip installs for missing skills)"
+  ).option(
+    "--force-modified",
+    "Allow replacing locally modified skills during update (creates backup before overwrite)"
+  ).option(
+    "--allow-blocked",
+    "Allow syncing compatibility-gated skills (explicit preview/testing only)"
+  ).option("--json", "Output machine-readable JSON").action(
+    async (name, opts) => {
+      const json = !!opts.json;
+      const config = loadConfig();
+      const installedNames = Object.keys(config.installedSkills);
+      let catalogNames = [];
+      if (!name || !opts.updatesOnly) {
+        try {
+          const catalog = await fetchSkillCatalog();
+          catalogNames = catalog.items.map((item) => item.name);
+        } catch (err) {
+          const error = `Could not fetch catalog: ${err instanceof Error ? err.message : String(err)}`;
+          if (json) {
+            console.log(JSON.stringify({ ok: false, error }));
+          } else {
+            console.error(error);
+          }
+          process.exit(1);
+        }
+      }
+      const resolved = resolveSyncTargets(
+        name,
+        catalogNames,
+        installedNames,
+        !!opts.updatesOnly
+      );
+      if (resolved.targets.length === 0) {
+        if (json) {
+          console.log(
+            JSON.stringify({
+              ok: true,
+              mode: resolved.mode,
+              totals: {
+                total: 0,
+                installed: 0,
+                updated: 0,
+                up_to_date: 0,
+                skipped_not_installed: 0,
+                skipped_compatibility: 0,
+                skipped_modified: 0,
+                failed: 0
+              },
+              results: []
+            })
+          );
+        } else {
+          console.log(
+            opts.updatesOnly ? "No installed skills found to sync." : "No catalog skills found to sync."
+          );
+        }
+        return;
+      }
+      const licenseGate = new LicenseGate();
+      const results = [];
+      for (const skillName of resolved.targets) {
+        const result = await syncOneSkill(skillName, {
+          updatesOnly: !!opts.updatesOnly,
+          forceModified: !!opts.forceModified,
+          allowBlocked: !!opts.allowBlocked,
+          json,
+          licenseGate
+        });
+        results.push(result);
+        if (!json) {
+          if (result.status === "failed") {
+            console.log(`  - ${skillName}: failed (${result.message ?? "unknown error"})`);
+          } else if (result.status === "skipped_compatibility" || result.status === "skipped_modified" || result.status === "skipped_not_installed") {
+            console.log(`  - ${skillName}: ${result.status} (${result.message ?? "n/a"})`);
+          }
+        }
+      }
+      const totals = {
+        total: results.length,
+        installed: results.filter((x) => x.status === "installed").length,
+        updated: results.filter((x) => x.status === "updated").length,
+        up_to_date: results.filter((x) => x.status === "up_to_date").length,
+        skipped_not_installed: results.filter((x) => x.status === "skipped_not_installed").length,
+        skipped_compatibility: results.filter((x) => x.status === "skipped_compatibility").length,
+        skipped_modified: results.filter((x) => x.status === "skipped_modified").length,
+        failed: results.filter((x) => x.status === "failed").length
+      };
+      const ok = results.every((x) => !SKIP_EXIT_BLOCKING_STATUSES.has(x.status));
+      if (json) {
+        console.log(
+          JSON.stringify(
+            {
+              ok,
+              mode: resolved.mode,
+              updatesOnly: !!opts.updatesOnly,
+              allowBlocked: !!opts.allowBlocked,
+              forceModified: !!opts.forceModified,
+              totals,
+              results
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log("");
+        console.log("Sync summary");
+        console.log(`  - total: ${totals.total}`);
+        console.log(`  - installed: ${totals.installed}`);
+        console.log(`  - updated: ${totals.updated}`);
+        console.log(`  - up_to_date: ${totals.up_to_date}`);
+        console.log(`  - skipped_not_installed: ${totals.skipped_not_installed}`);
+        console.log(`  - skipped_compatibility: ${totals.skipped_compatibility}`);
+        console.log(`  - skipped_modified: ${totals.skipped_modified}`);
+        console.log(`  - failed: ${totals.failed}`);
+      }
+      if (!ok) {
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+
+// src/lib/version.ts
+var import_fs14 = require("fs");
+var import_path15 = require("path");
+var FALLBACK_VERSION = "0.0.0";
+var cachedVersion = null;
+function candidatePackageJsonPaths(deps) {
+  const cwd = deps.cwd ?? process.cwd();
+  const scriptPath = deps.scriptPath ?? process.argv[1] ?? null;
+  const env = deps.env ?? process.env;
+  const candidates = [
+    typeof env.PUSHREC_CLI_PACKAGE_JSON === "string" ? env.PUSHREC_CLI_PACKAGE_JSON : null,
+    scriptPath ? (0, import_path15.join)((0, import_path15.dirname)((0, import_path15.resolve)(scriptPath)), "..", "package.json") : null,
+    (0, import_path15.join)(cwd, "package.json"),
+    (0, import_path15.join)(cwd, "cli", "package.json")
+  ].filter((path) => typeof path === "string" && path.length > 0);
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((path) => {
+    if (seen.has(path)) return false;
+    seen.add(path);
+    return true;
+  });
+}
+function parseVersionFromPackageJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version !== "string") return null;
+    const version = parsed.version.trim();
+    return version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+function getCliVersion(deps = {}) {
+  if (cachedVersion && deps.cwd === void 0 && deps.scriptPath === void 0 && deps.env === void 0 && deps.existsSyncFn === void 0 && deps.readFileSyncFn === void 0) {
+    return cachedVersion;
+  }
+  const existsFn = deps.existsSyncFn ?? import_fs14.existsSync;
+  const readFn = deps.readFileSyncFn ?? import_fs14.readFileSync;
+  for (const packageJsonPath of candidatePackageJsonPaths(deps)) {
+    if (!existsFn(packageJsonPath)) continue;
+    try {
+      const raw = readFn(packageJsonPath, "utf-8");
+      const version = parseVersionFromPackageJson(raw);
+      if (!version) continue;
+      if (deps.cwd === void 0 && deps.scriptPath === void 0 && deps.env === void 0 && deps.existsSyncFn === void 0 && deps.readFileSyncFn === void 0) {
+        cachedVersion = version;
+      }
+      return version;
+    } catch {
+      continue;
+    }
+  }
+  return FALLBACK_VERSION;
+}
+
 // src/index.ts
-var program = new import_commander10.Command();
+var program = new import_commander13.Command();
 program.name("pushrec-skills").description(
   "Install, update, and manage premium Claude Code skills from Pushrec"
-).version("0.2.0");
+).version(getCliVersion());
 program.addCommand(authCommand());
 program.addCommand(installCommand());
 program.addCommand(updateCommand());
@@ -1806,6 +4063,9 @@ program.addCommand(infoCommand());
 program.addCommand(createUninstallCommand());
 program.addCommand(healthCommand());
 program.addCommand(setupCommand());
+program.addCommand(dashboardCommand());
+program.addCommand(rollbackCommand());
+program.addCommand(syncCommand());
 program.parseAsync().catch((err) => {
   console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);