@@ -224,25 +224,45 @@ async def delete_skill(self, repo_id: str) -> None:
     # ── Private Helpers ───────────────────────────────────────────────────
 
     async def _ensure_repo(self, repo_id: str, visibility: Visibility) -> None:
-        """Create repository if it doesn't exist."""
+        """Create repository if it doesn't exist.
+
+        Handles both personal repos (POST /user/repos) and org repos
+        (POST /orgs/{org}/repos) based on owner identity.
+        """
         parts = repo_id.split("/")
         if len(parts) != 2:
             raise ValueError(f"Invalid repo_id format: '{repo_id}' (expected 'owner/name')")
-        _, name = parts
+        owner, name = parts
 
         # Check if repo exists
         resp = await self._http.get(f"/repos/{repo_id}")
         if resp.status_code == 200:
             return  # Already exists
 
-        # Create repo
+        # Determine if owner is the authenticated user or an org
         private = visibility != Visibility.PUBLIC
-        create_resp = await self._http.post("/user/repos", json={
-            "name": name,
-            "private": private,
-            "auto_init": True,
-            "description": f"LeapFlow skill: {name}",
-        })
+        user_resp = await self._http.get("/user")
+        is_personal = (
+            user_resp.status_code == 200
+            and user_resp.json().get("login", "") == owner
+        )
+
+        if is_personal:
+            create_resp = await self._http.post("/user/repos", json={
+                "name": name,
+                "private": private,
+                "auto_init": True,
+                "description": f"LeapFlow skill: {name}",
+            })
+        else:
+            # Organization repo
+            create_resp = await self._http.post(f"/orgs/{owner}/repos", json={
+                "name": name,
+                "private": private,
+                "auto_init": True,
+                "description": f"LeapFlow skill: {name}",
+            })
+
         if create_resp.status_code not in (201, 422):
             create_resp.raise_for_status()
 
 
@@ -27,6 +27,19 @@
 logger = logging.getLogger(__name__)
 
 
+def _semver_key(version: str) -> tuple:
+    """Parse version string to comparable tuple for correct semver sorting.
+
+    Handles formats: '0.1.0', 'v1.2.3', '1.0'.
+    Returns (0, 0, 0) on parse failure for safe fallback.
+    """
+    cleaned = version.strip().lstrip("v")
+    try:
+        return tuple(int(x) for x in cleaned.split("."))
+    except (ValueError, AttributeError):
+        return (0, 0, 0)
+
+
 class LocalBackend:
     """HubBackend using local filesystem as storage.
 
@@ -54,6 +67,26 @@ def base_dir(self) -> Path:
         """Return the base directory for local storage."""
         return self._base_dir
 
+    def _safe_repo_path(self, repo_id: str) -> Path:
+        """Validate repo_id and resolve to safe path under base_dir.
+
+        Prevents path traversal attacks via '..' segments or absolute paths.
+        """
+        from pathlib import PurePosixPath
+
+        parts = PurePosixPath(repo_id).parts
+        if not parts:
+            raise ValueError(f"Empty repo_id")
+        if any(p == ".." for p in parts):
+            raise ValueError(f"Path traversal detected in repo_id: '{repo_id}'")
+        if PurePosixPath(repo_id).is_absolute():
+            raise ValueError(f"Absolute path not allowed in repo_id: '{repo_id}'")
+
+        resolved = (self._base_dir / repo_id).resolve()
+        if not str(resolved).startswith(str(self._base_dir.resolve())):
+            raise ValueError(f"repo_id escapes base directory: '{repo_id}'")
+        return resolved
+
     async def authenticate(self) -> UserInfo:
         """Return local user info (no actual authentication needed)."""
         username = os.environ.get("USER", os.environ.get("USERNAME", "local"))
@@ -65,13 +98,9 @@ async def push_skill(
         repo_id: str,
         visibility: Visibility = Visibility.PRIVATE,
     ) -> PushResult:
-        """Write skill bundle to local filesystem.
-
-        Creates a versioned directory structure:
-        base_dir/repo_id/version/files...
-        """
+        """Write skill bundle to local filesystem."""
         version = bundle.manifest.version or "0.1.0"
-        repo_path = self._base_dir / repo_id / version
+        repo_path = self._safe_repo_path(repo_id) / version
         repo_path.mkdir(parents=True, exist_ok=True)
 
         # Write files
@@ -95,20 +124,18 @@ async def pull_skill(
         version: Optional[str] = None,
     ) -> SkillBundle:
         """Read skill bundle from local filesystem."""
-        repo_base = self._base_dir / repo_id
+        repo_base = self._safe_repo_path(repo_id)
 
         if not repo_base.exists():
             raise FileNotFoundError(f"Skill repository not found: {repo_id}")
 
         # Resolve version
         if version is None:
-            # Get latest version (sorted lexicographically)
-            versions = sorted(
-                [d.name for d in repo_base.iterdir() if d.is_dir()],
-                reverse=True,
-            )
-            if not versions:
+            # Get latest version (semantic version sort, not lexicographic)
+            version_dirs = [d.name for d in repo_base.iterdir() if d.is_dir()]
+            if not version_dirs:
                 raise FileNotFoundError(f"No versions found for: {repo_id}")
+            versions = sorted(version_dirs, key=_semver_key, reverse=True)
             version = versions[0]
 
         version_path = repo_base / version
@@ -221,7 +248,7 @@ async def delete_skill(self, repo_id: str) -> None:
         """Delete a skill from local storage."""
         import shutil
 
-        repo_base = self._base_dir / repo_id
+        repo_base = self._safe_repo_path(repo_id)
 
         if not repo_base.exists():
             raise FileNotFoundError(f"Skill repository not found: {repo_id}")
 
@@ -142,13 +142,17 @@ async def pull_skill(
                 **kwargs,
             )
 
-            # Read all files from downloaded directory
+            # Read all files in a thread to avoid blocking the event loop
+            def _read_files(local_path: Path) -> dict:
+                files: dict[str, str] = {}
+                for file_path in local_path.rglob("*"):
+                    if file_path.is_file() and not file_path.name.startswith("."):
+                        rel = file_path.relative_to(local_path)
+                        files[str(rel)] = file_path.read_text(encoding="utf-8")
+                return files
+
             local_path = Path(local_dir)
-            files: dict[str, str] = {}
-            for file_path in local_path.rglob("*"):
-                if file_path.is_file() and not file_path.name.startswith("."):
-                    rel = file_path.relative_to(local_path)
-                    files[str(rel)] = file_path.read_text(encoding="utf-8")
+            files = await asyncio.to_thread(_read_files, local_path)
 
             return self._serializer.files_to_bundle(files)
 
 
@@ -26,8 +26,11 @@
 # ─── Sync Plan ───────────────────────────────────────────────────────────────
 
 
-class SyncPlan:
-    """Plan describing what needs to happen during a sync operation."""
+class ClientSyncPlan:
+    """Lightweight sync plan for HubClient.sync_skills() preview.
+
+    Distinct from leapflow.hub.sync.SyncPlan (full engine-level plan).
+    """
 
     def __init__(
         self,
@@ -325,7 +328,7 @@ async def sync_skills(
             if name not in local_by_name:
                 to_pull.append(remote)
 
-        return SyncPlan(to_push=to_push, to_pull=to_pull, conflicts=conflicts)
+        return ClientSyncPlan(to_push=to_push, to_pull=to_pull, conflicts=conflicts)
 
     async def login(self) -> UserInfo:
         """Authenticate with the hub backend.
 
@@ -75,13 +75,20 @@ def _serialize_manifest(manifest: SkillManifest) -> str:
 
 
 def _deserialize_manifest(text: str) -> SkillManifest:
-    """Deserialize manifest from YAML or JSON."""
+    """Deserialize manifest from YAML or JSON with graceful fallback."""
+    data = None
     if _YAML_AVAILABLE:
-        data = yaml.safe_load(text)
-    else:
-        # Try JSON first, fallback to basic parsing
-        data = json.loads(text)
-    return _dict_to_manifest(data if data else {})
+        try:
+            data = yaml.safe_load(text)
+        except Exception:
+            logger.debug("YAML parse failed for manifest; trying JSON fallback")
+    if data is None:
+        try:
+            data = json.loads(text)
+        except (json.JSONDecodeError, ValueError):
+            logger.warning("Failed to parse manifest as YAML or JSON")
+            data = None
+    return _dict_to_manifest(data if isinstance(data, dict) else {})
 
 
 # ─── SkillSerializer ─────────────────────────────────────────────────────────
 
@@ -146,11 +146,33 @@ async def hub_pull_tool(
     serializer = SkillSerializer()
     skill_data = serializer.import_skill(bundle)
 
+    # Attempt to save to local skill library if context available
+    ctx = kwargs.get("ctx")
+    if ctx is not None and hasattr(ctx, "skill_lib") and ctx.skill_lib is not None:
+        if high_risk:
+            return (
+                f"Pulled '{bundle.manifest.name}' v{bundle.manifest.version} "
+                f"from {repo_id} but NOT installed due to {len(high_risk)} "
+                f"high-risk finding(s).{finding_text}\n"
+                f"Use CLI 'leap hub pull {repo_id} --trust' to install with risks accepted."
+            )
+        try:
+            ctx.skill_lib.save_from_hub(skill_data)
+            return (
+                f"Pulled and installed '{bundle.manifest.name}' "
+                f"v{bundle.manifest.version} from {repo_id}.{finding_text}"
+            )
+        except Exception as e:
+            return (
+                f"Pulled '{bundle.manifest.name}' v{bundle.manifest.version} "
+                f"from {repo_id} but install failed: {e}.{finding_text}"
+            )
+
     return (
         f"Pulled '{bundle.manifest.name}' v{bundle.manifest.version} "
         f"from {repo_id}.{finding_text}\n"
-        f"Skill is ready for local installation. "
-        f"Use 'hub pull {repo_id} --trust' in CLI to install directly."
+        f"Skill library context not available; skill was not installed. "
+        f"Use 'leap hub pull {repo_id}' in CLI to install."
     )
 
 
@@ -219,10 +241,22 @@ async def hub_sync_tool(
         repo_prefix=settings.hub_repo_prefix,
     )
 
-    # For tool context we use empty manifests as placeholder
-    # Real implementation would access skill_lib from ctx
+    # Load actual local skills from context if available
+    ctx = kwargs.get("ctx")
+    local_manifests: list = []
+    if ctx is not None and hasattr(ctx, "skill_lib") and ctx.skill_lib is not None:
+        try:
+            stored_skills = ctx.skill_lib.load_all_active()
+            for s in stored_skills:
+                local_manifests.append(SkillManifest(
+                    name=getattr(s, "title", ""),
+                    version=str(getattr(s, "version", "0.1.0")),
+                ))
+        except Exception:
+            pass  # Fall through to empty manifests
+
     try:
-        plan = await client.sync_skills([])
+        plan = await client.sync_skills(local_manifests)
     except Exception as e:
         return f"Sync failed: {type(e).__name__}: {e}"