diff --git a/.hlint.yaml b/.hlint.yaml
--- a/.hlint.yaml
+++ b/.hlint.yaml
@@ -620,15 +620,51 @@
     - message: "Partial: throws on 0 or >1 elements. Consider using (^?) or ensure exactly 1 element."
       name: Control.Lens.Traversal.singular
       within: []
+    - message: "Partial: throws on 0 or >1 elements. Consider using (^?) or ensure exactly 1 element."
+      name: Himari.singular
+      within: []
+    - message: "Partial: throws on 0 or >1 elements. Consider using (^?) or ensure exactly 1 element."
+      name: Himari.Prelude.singular
+      within: []
+    - message: "Partial: throws on 0 or >1 elements. Consider using (^?) or ensure exactly 1 element."
+      name: Himari.SafePrelude.singular
+      within: []
     - message: "Partial: throws on 0 or >1 elements."
       name: Control.Lens.Traversal.unsafeSingular
       within: []
+    - message: "Partial: throws on 0 or >1 elements."
+      name: Himari.unsafeSingular
+      within: []
+    - message: "Partial: throws on 0 or >1 elements."
+      name: Himari.Prelude.unsafeSingular
+      within: []
+    - message: "Partial: throws on 0 or >1 elements."
+      name: Himari.SafePrelude.unsafeSingular
+      within: []
     - message: "Unsafe: may throw if list length changes."
       name: Control.Lens.Traversal.unsafePartsOf
       within: []
     - message: "Unsafe: may throw if list length changes."
+      name: Himari.unsafePartsOf
+      within: []
+    - message: "Unsafe: may throw if list length changes."
+      name: Himari.Prelude.unsafePartsOf
+      within: []
+    - message: "Unsafe: may throw if list length changes."
+      name: Himari.SafePrelude.unsafePartsOf
+      within: []
+    - message: "Unsafe: may throw if list length changes."
       name: Control.Lens.Traversal.iunsafePartsOf
       within: []
+    - message: "Unsafe: may throw if list length changes."
+      name: Himari.iunsafePartsOf
+      within: []
+    - message: "Unsafe: may throw if list length changes."
+      name: Himari.Prelude.iunsafePartsOf
+      within: []
+    - message: "Unsafe: may throw if list length changes."
+      name: Himari.SafePrelude.iunsafePartsOf
+      within: []
 - functions:
     - message: "Unsound: violates lens laws unless lenses are disjoint. Use alongside instead."
       name: Control.Lens.Unsound.lensProduct
@@ -877,27 +913,90 @@
     - message: "Partial: throws on empty list. Use headMay or headDef from Safe instead."
       name: Data.List.head
       within: []
+    - message: "Partial: throws on empty list. Use headMay or headDef from Safe instead."
+      name: Himari.head
+      within: []
+    - message: "Partial: throws on empty list. Use headMay or headDef from Safe instead."
+      name: Himari.Prelude.head
+      within: []
+    - message: "Partial: throws on empty list. Use headMay or headDef from Safe instead."
+      name: Himari.SafePrelude.head
+      within: []
     - message: "Partial: throws on empty list. Use tailMay, tailDef, or tailSafe from Safe instead."
       name: Data.List.tail
       within: []
+    - message: "Partial: throws on empty list. Use tailMay, tailDef, or tailSafe from Safe instead."
+      name: Himari.tail
+      within: []
+    - message: "Partial: throws on empty list. Use tailMay, tailDef, or tailSafe from Safe instead."
+      name: Himari.Prelude.tail
+      within: []
+    - message: "Partial: throws on empty list. Use tailMay, tailDef, or tailSafe from Safe instead."
+      name: Himari.SafePrelude.tail
+      within: []
     - message: "Partial: throws on empty list. Use initMay, initDef, or initSafe from Safe instead."
       name: Data.List.init
       within: []
+    - message: "Partial: throws on empty list. Use initMay, initDef, or initSafe from Safe instead."
+      name: Himari.init
+      within: []
+    - message: "Partial: throws on empty list. Use initMay, initDef, or initSafe from Safe instead."
+      name: Himari.Prelude.init
+      within: []
+    - message: "Partial: throws on empty list. Use initMay, initDef, or initSafe from Safe instead."
+      name: Himari.SafePrelude.init
+      within: []
     - message: "Partial: throws on empty list. Use lastMay or lastDef from Safe instead."
       name: Data.List.last
       within: []
+    - message: "Partial: throws on empty list. Use lastMay or lastDef from Safe instead."
+      name: Himari.last
+      within: []
+    - message: "Partial: throws on empty list. Use lastMay or lastDef from Safe instead."
+      name: Himari.Prelude.last
+      within: []
+    - message: "Partial: throws on empty list. Use lastMay or lastDef from Safe instead."
+      name: Himari.SafePrelude.last
+      within: []
     - message: "Partial: throws on out-of-bounds. Use atMay or atDef from Safe instead."
       name: "Data.List.!!"
       within: []
     - message: "Partial: throws on empty list. Use cycleMay or cycleDef from Safe instead."
       name: Data.List.cycle
       within: []
+    - message: "Partial: throws on empty list. Use cycleMay or cycleDef from Safe instead."
+      name: Himari.cycle
+      within: []
+    - message: "Partial: throws on empty list. Use cycleMay or cycleDef from Safe instead."
+      name: Himari.Prelude.cycle
+      within: []
+    - message: "Partial: throws on empty list. Use cycleMay or cycleDef from Safe instead."
+      name: Himari.SafePrelude.cycle
+      within: []
     - message: "Partial: throws on empty list. Use scanl1May or scanl1Def from Safe instead."
       name: Data.List.scanl1
       within: []
+    - message: "Partial: throws on empty list. Use scanl1May or scanl1Def from Safe instead."
+      name: Himari.scanl1
+      within: []
+    - message: "Partial: throws on empty list. Use scanl1May or scanl1Def from Safe instead."
+      name: Himari.Prelude.scanl1
+      within: []
+    - message: "Partial: throws on empty list. Use scanl1May or scanl1Def from Safe instead."
+      name: Himari.SafePrelude.scanl1
+      within: []
     - message: "Partial: throws on empty list. Use scanr1May or scanr1Def from Safe instead."
       name: Data.List.scanr1
       within: []
+    - message: "Partial: throws on empty list. Use scanr1May or scanr1Def from Safe instead."
+      name: Himari.scanr1
+      within: []
+    - message: "Partial: throws on empty list. Use scanr1May or scanr1Def from Safe instead."
+      name: Himari.Prelude.scanr1
+      within: []
+    - message: "Partial: throws on empty list. Use scanr1May or scanr1Def from Safe instead."
+      name: Himari.SafePrelude.scanr1
+      within: []
     - message: "Partial: throws on empty list. Use foldl1May from Safe instead."
       name: Data.List.foldl1
       within: []
@@ -923,6 +1022,15 @@
     - message: "Partial: throws on Nothing. Use fromMaybe or pattern match instead."
       name: Data.Maybe.fromJust
       within: []
+    - message: "Partial: throws on Nothing. Use fromMaybe or pattern match instead."
+      name: Himari.fromJust
+      within: []
+    - message: "Partial: throws on Nothing. Use fromMaybe or pattern match instead."
+      name: Himari.Prelude.fromJust
+      within: []
+    - message: "Partial: throws on Nothing. Use fromMaybe or pattern match instead."
+      name: Himari.SafePrelude.fromJust
+      within: []
 - functions:
     - message: "Partial: throws on parse failure. Use readMay or readDef from Safe instead."
       name: read
@@ -931,40 +1039,148 @@
     - message: "Partial: throws on empty structure. Use foldl1May from Safe.Foldable instead."
       name: Data.Foldable.foldl1
       within: []
+    - message: "Partial: throws on empty structure. Use foldl1May from Safe.Foldable instead."
+      name: Himari.foldl1
+      within: []
+    - message: "Partial: throws on empty structure. Use foldl1May from Safe.Foldable instead."
+      name: Himari.Prelude.foldl1
+      within: []
+    - message: "Partial: throws on empty structure. Use foldl1May from Safe.Foldable instead."
+      name: Himari.SafePrelude.foldl1
+      within: []
     - message: "Partial: throws on empty structure. Use foldr1May from Safe.Foldable instead."
       name: Data.Foldable.foldr1
       within: []
+    - message: "Partial: throws on empty structure. Use foldr1May from Safe.Foldable instead."
+      name: Himari.foldr1
+      within: []
+    - message: "Partial: throws on empty structure. Use foldr1May from Safe.Foldable instead."
+      name: Himari.Prelude.foldr1
+      within: []
+    - message: "Partial: throws on empty structure. Use foldr1May from Safe.Foldable instead."
+      name: Himari.SafePrelude.foldr1
+      within: []
     - message: "Partial: throws on empty structure. Use maximumMay or maximumBound from Safe.Foldable instead."
       name: Data.Foldable.maximum
       within: []
+    - message: "Partial: throws on empty structure. Use maximumMay or maximumBound from Safe.Foldable instead."
+      name: Himari.maximum
+      within: []
+    - message: "Partial: throws on empty structure. Use maximumMay or maximumBound from Safe.Foldable instead."
+      name: Himari.Prelude.maximum
+      within: []
+    - message: "Partial: throws on empty structure. Use maximumMay or maximumBound from Safe.Foldable instead."
+      name: Himari.SafePrelude.maximum
+      within: []
     - message: "Partial: throws on empty structure. Use minimumMay or minimumBound from Safe.Foldable instead."
       name: Data.Foldable.minimum
       within: []
+    - message: "Partial: throws on empty structure. Use minimumMay or minimumBound from Safe.Foldable instead."
+      name: Himari.minimum
+      within: []
+    - message: "Partial: throws on empty structure. Use minimumMay or minimumBound from Safe.Foldable instead."
+      name: Himari.Prelude.minimum
+      within: []
+    - message: "Partial: throws on empty structure. Use minimumMay or minimumBound from Safe.Foldable instead."
+      name: Himari.SafePrelude.minimum
+      within: []
     - message: "Partial: throws on empty structure. Use maximumByMay or maximumBoundBy from Safe.Foldable instead."
       name: Data.Foldable.maximumBy
       within: []
+    - message: "Partial: throws on empty structure. Use maximumByMay or maximumBoundBy from Safe.Foldable instead."
+      name: Himari.maximumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use maximumByMay or maximumBoundBy from Safe.Foldable instead."
+      name: Himari.Prelude.maximumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use maximumByMay or maximumBoundBy from Safe.Foldable instead."
+      name: Himari.SafePrelude.maximumBy
+      within: []
     - message: "Partial: throws on empty structure. Use minimumByMay or minimumBoundBy from Safe.Foldable instead."
       name: Data.Foldable.minimumBy
       within: []
+    - message: "Partial: throws on empty structure. Use minimumByMay or minimumBoundBy from Safe.Foldable instead."
+      name: Himari.minimumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use minimumByMay or minimumBoundBy from Safe.Foldable instead."
+      name: Himari.Prelude.minimumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use minimumByMay or minimumBoundBy from Safe.Foldable instead."
+      name: Himari.SafePrelude.minimumBy
+      within: []
 - functions:
     - message: "Partial: throws on empty structure. Use bifoldl with a default value instead."
       name: Data.Bifoldable.bifoldl1
       within: []
+    - message: "Partial: throws on empty structure. Use bifoldl with a default value instead."
+      name: Himari.bifoldl1
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldl with a default value instead."
+      name: Himari.Prelude.bifoldl1
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldl with a default value instead."
+      name: Himari.SafePrelude.bifoldl1
+      within: []
     - message: "Partial: throws on empty structure. Use bifoldr with a default value instead."
       name: Data.Bifoldable.bifoldr1
       within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with a default value instead."
+      name: Himari.bifoldr1
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with a default value instead."
+      name: Himari.Prelude.bifoldr1
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with a default value instead."
+      name: Himari.SafePrelude.bifoldr1
+      within: []
     - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
       name: Data.Bifoldable.bimaximum
       within: []
     - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.bimaximum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.Prelude.bimaximum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.SafePrelude.bimaximum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
       name: Data.Bifoldable.biminimum
       within: []
     - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.biminimum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.Prelude.biminimum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.SafePrelude.biminimum
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
       name: Data.Bifoldable.bimaximumBy
       within: []
     - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.bimaximumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.Prelude.bimaximumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.SafePrelude.bimaximumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
       name: Data.Bifoldable.biminimumBy
       within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.biminimumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.Prelude.biminimumBy
+      within: []
+    - message: "Partial: throws on empty structure. Use bifoldr with explicit initial value."
+      name: Himari.SafePrelude.biminimumBy
+      within: []
 - functions:
     - message: "Partial: throws on out-of-bounds. Use atMay or atDef from Safe with toList instead."
       name: "Data.List.NonEmpty.!!"
@@ -1153,41 +1369,158 @@
       name: System.IO.getChar
       within: []
     - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.getChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.getChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.getChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
       name: System.IO.getLine
       within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.getLine
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.getLine
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.getLine
+      within: []
     - message: "Lazy IO + env-dependent encoding. Use strict Text or ByteString."
       name: System.IO.getContents
       within: []
+    - message: "Lazy IO + env-dependent encoding. Use strict Text or ByteString."
+      name: Himari.getContents
+      within: []
+    - message: "Lazy IO + env-dependent encoding. Use strict Text or ByteString."
+      name: Himari.Prelude.getContents
+      within: []
+    - message: "Lazy IO + env-dependent encoding. Use strict Text or ByteString."
+      name: Himari.SafePrelude.getContents
+      within: []
     - message: "Lazy IO + env-dependent encoding. Use Data.Text.IO.readFile or Data.ByteString.readFile."
       name: System.IO.readFile
       within: []
+    - message: "Lazy IO + env-dependent encoding. Use Data.Text.IO.readFile or Data.ByteString.readFile."
+      name: Himari.readFile
+      within: []
+    - message: "Lazy IO + env-dependent encoding. Use Data.Text.IO.readFile or Data.ByteString.readFile."
+      name: Himari.Prelude.readFile
+      within: []
+    - message: "Lazy IO + env-dependent encoding. Use Data.Text.IO.readFile or Data.ByteString.readFile."
+      name: Himari.SafePrelude.readFile
+      within: []
     - message: "Lazy IO + env-dependent encoding."
       name: System.IO.interact
       within: []
+    - message: "Lazy IO + env-dependent encoding."
+      name: Himari.interact
+      within: []
+    - message: "Lazy IO + env-dependent encoding."
+      name: Himari.Prelude.interact
+      within: []
+    - message: "Lazy IO + env-dependent encoding."
+      name: Himari.SafePrelude.interact
+      within: []
     - message: "Env-dependent + partial (uses read)."
       name: System.IO.readIO
       within: []
     - message: "Env-dependent + partial (uses read)."
+      name: Himari.readIO
+      within: []
+    - message: "Env-dependent + partial (uses read)."
+      name: Himari.Prelude.readIO
+      within: []
+    - message: "Env-dependent + partial (uses read)."
+      name: Himari.SafePrelude.readIO
+      within: []
+    - message: "Env-dependent + partial (uses read)."
       name: System.IO.readLn
       within: []
+    - message: "Env-dependent + partial (uses read)."
+      name: Himari.readLn
+      within: []
+    - message: "Env-dependent + partial (uses read)."
+      name: Himari.Prelude.readLn
+      within: []
+    - message: "Env-dependent + partial (uses read)."
+      name: Himari.SafePrelude.readLn
+      within: []
     - message: Encoding depends on LANG env. Use Text or ByteString.
       name: System.IO.putChar
       within: []
     - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.putChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.putChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.putChar
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
       name: System.IO.putStr
       within: []
     - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.putStr
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.putStr
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.putStr
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
       name: System.IO.putStrLn
       within: []
     - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.putStrLn
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.putStrLn
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.putStrLn
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
       name: System.IO.print
       within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.print
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.Prelude.print
+      within: []
+    - message: Encoding depends on LANG env. Use Text or ByteString.
+      name: Himari.SafePrelude.print
+      within: []
     - message: "Env-dependent encoding. Use Data.Text.IO.writeFile or Data.ByteString.writeFile."
       name: System.IO.writeFile
       within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.writeFile or Data.ByteString.writeFile."
+      name: Himari.writeFile
+      within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.writeFile or Data.ByteString.writeFile."
+      name: Himari.Prelude.writeFile
+      within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.writeFile or Data.ByteString.writeFile."
+      name: Himari.SafePrelude.writeFile
+      within: []
     - message: "Env-dependent encoding. Use Data.Text.IO.appendFile or Data.ByteString.appendFile."
       name: System.IO.appendFile
       within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.appendFile or Data.ByteString.appendFile."
+      name: Himari.appendFile
+      within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.appendFile or Data.ByteString.appendFile."
+      name: Himari.Prelude.appendFile
+      within: []
+    - message: "Env-dependent encoding. Use Data.Text.IO.appendFile or Data.ByteString.appendFile."
+      name: Himari.SafePrelude.appendFile
+      within: []
 - functions:
     - message: Use Data.Text.uncons instead
       name: Data.Text.head
@@ -1348,6 +1681,12 @@
       within: []
     - message: Use typed exceptions instead. Define a proper exception type.
       name: UnliftIO.Exception.stringException
+      within: []
+    - message: Use typed exceptions instead. Define a proper exception type.
+      name: Himari.stringException
+      within: []
+    - message: Use typed exceptions instead. Define a proper exception type.
+      name: Himari.Prelude.stringException
       within: []
 - functions:
     - message: Use UnliftIO.Async.async instead for MonadUnliftIO support.
diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,27 @@
 
 ## [Unreleased]
 
+## [1.1.6.3] - 2026-11-19
+
+### Fixed
+
+- hlint rules written with a module-qualified name,
+  such as `Data.List.head` and `System.IO.readFile`,
+  did not match symbols used through `import Himari`,
+  because hlint does not follow re-exports.
+  The functions listed in the following items are now warned when used through `Himari`,
+  `Himari.Prelude`, or `Himari.SafePrelude`.
+  Projects that use them through these modules will get new warnings
+- Warn partial functions of `Data.List`, `Data.Foldable`, and `Data.Bifoldable`
+  used through himari, such as `head`, `tail`, `foldl1`, `maximum`, and `bifoldl1`
+- Warn `fromJust` of `Data.Maybe` used through himari
+- Warn `String` IO functions of `System.IO` used through himari,
+  such as `print`, `putStrLn`, `getLine`, and `readFile`
+- Warn `singular`, `unsafeSingular`, `unsafePartsOf`, and `iunsafePartsOf`
+  of `Control.Lens.Traversal` used through himari
+- Warn `stringException` of `UnliftIO.Exception` used through `Himari` or `Himari.Prelude`.
+  `Himari.SafePrelude` does not export it
+
 ## [1.1.6.2] - 2026-11-01
 
 ### Changed
diff --git a/himari.cabal b/himari.cabal
--- a/himari.cabal
+++ b/himari.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.12
 name: himari
-version: 1.1.6.2
+version: 1.1.6.3
 synopsis: A standard library for Haskell as an alternative to rio
 description:
   A standard library for Haskell inspired by rio.
@@ -153,8 +153,15 @@
     Himari.Title
     HlintBaseSpec
     HlintExtensionSpec
+    HlintReexportSpec
+    HlintRunner
     HlintSamples.BasePartial
     HlintSamples.ExtensionDangerous
+    HlintSamples.ReexportExplicitImport
+    HlintSamples.ReexportHimari
+    HlintSamples.ReexportHimariPrelude
+    HlintSamples.ReexportImportForms
+    HlintSamples.ReexportSafePrelude
     HlintSamples.UnliftioPreference
     HlintUnliftioSpec
     TitleSpec
@@ -168,6 +175,7 @@
     QuickCheck >=2.15.0.1,
     himari,
     sydtest >=0.18.0.0,
+    yaml >=0.11.11.2,
 
   build-tool-depends:
     hlint:hlint >=3.10
diff --git a/test/HlintBaseSpec.hs b/test/HlintBaseSpec.hs
--- a/test/HlintBaseSpec.hs
+++ b/test/HlintBaseSpec.hs
@@ -1,65 +1,49 @@
 module HlintBaseSpec (spec) where
 
-import Data.Text qualified as T
 import Himari
+import HlintRunner
 import Test.Syd
 
 spec :: Spec
 spec = do
-  describe "hlint base library rules" . beforeAll runHlintOnSample $ do
+  describe "hlint base library rules" . withSample "BasePartial.hs" $ do
     describe "Data.List partial functions" $ do
-      itWithOuter "Data.List.head should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarning "headMay"
+      itWithOuter "head through Himari should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useHead" "head" "headMay"
 
+      itWithOuter "Data.List.head should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useHeadQualified" "L.head" "headMay"
+
     describe "NonEmpty.head should be safe" $ do
-      itWithOuter "Data.List.NonEmpty.head should NOT warn (it's safe)" $ \output -> do
-        output `shouldSatisfy` notContainsWarningAt "useNonEmptyHead"
+      itWithOuter "Data.List.NonEmpty.head should NOT warn (it's safe)" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useNonEmptyHead"
 
     describe "Debug.Trace functions suggest pTrace*" $ do
-      itWithOuter "Debug.Trace.trace should suggest pTrace" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "trace" "pTrace"
+      itWithOuter "Debug.Trace.trace should suggest pTrace" $ \sample ->
+        shouldSuggestIn sample "useTrace" "Use pTrace"
 
-      itWithOuter "Debug.Trace.traceShow should suggest pTraceShow" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "traceShow" "pTraceShow"
+      itWithOuter "Debug.Trace.traceShow should suggest pTraceShow" $ \sample ->
+        shouldSuggestIn sample "useTraceShow" "Use pTraceShow"
 
-      itWithOuter "Debug.Trace.traceM should suggest pTraceM" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "traceM" "pTraceM"
+      itWithOuter "Debug.Trace.traceM should suggest pTraceM" $ \sample ->
+        shouldSuggestIn sample "useTraceM" "Use pTraceM"
 
     describe "Numeric integer-showing functions are partial" $ do
-      itWithOuter "showHex should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "showHex" "non-negative"
-
-      itWithOuter "showInt should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "showInt" "non-negative"
-
-      itWithOuter "showOct should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "showOct" "non-negative"
-
-      itWithOuter "showBin should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "showBin" "non-negative"
+      itWithOuter "showHex should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowHex" "showHex" "non-negative"
 
-      itWithOuter "showIntAtBase should warn (partial function)" $ \output -> do
-        output `shouldSatisfy` containsWarningAt "showIntAtBase" "base > 1"
+      itWithOuter "showInt should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowInt" "showInt" "non-negative"
 
-runHlintOnSample :: IO Text
-runHlintOnSample = do
-  (exitCode, stdoutOutput, stderrOutput) <-
-    readProcess $
-      proc "hlint" ["test/HlintSamples/BasePartial.hs"]
-  pure $ case exitCode of
-    ExitSuccess -> convert stdoutOutput
-    ExitFailure _ -> convert stdoutOutput <> convert stderrOutput
+      itWithOuter "showOct should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowOct" "showOct" "non-negative"
 
-containsWarning :: Text -> Text -> Bool
-containsWarning expectedMsg output = expectedMsg `T.isInfixOf` output
+      itWithOuter "showBin should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowBin" "showBin" "non-negative"
 
-containsWarningAt :: Text -> Text -> Text -> Bool
-containsWarningAt funcName expectedMsg output =
-  let msgAndFunc = funcName `T.isInfixOf` output && expectedMsg `T.isInfixOf` output
-   in msgAndFunc
+      itWithOuter "showIntAtBase should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowIntAtBase" "showIntAtBase" "base > 1"
 
-notContainsWarningAt :: Text -> Text -> Bool
-notContainsWarningAt funcName output =
-  let linesWithFunc =
-        filter (T.isInfixOf funcName) (T.lines output)
-   in null linesWithFunc
+    describe "Data.Char partial functions" $ do
+      itWithOuter "intToDigit should warn (partial function)" $ \sample ->
+        shouldWarnFunction sample "useShowIntAtBase" "intToDigit" "intToDigitMay"
diff --git a/test/HlintExtensionSpec.hs b/test/HlintExtensionSpec.hs
--- a/test/HlintExtensionSpec.hs
+++ b/test/HlintExtensionSpec.hs
@@ -1,31 +1,19 @@
 module HlintExtensionSpec (spec) where
 
-import Data.Text qualified as T
 import Himari
+import HlintRunner
 import Test.Syd
 
 spec :: Spec
 spec = do
-  describe "hlint extension restriction rules" . beforeAll runHlintOnSample $ do
+  describe "hlint extension restriction rules" . withSample "ExtensionDangerous.hs" $ do
     describe "Dangerous extensions" $ do
-      itWithOuter "AllowAmbiguousTypes should warn" $ \output -> do
-        output `shouldSatisfy` containsWarning "AllowAmbiguousTypes"
+      itWithOuter "AllowAmbiguousTypes should warn" $ \sample ->
+        sample `shouldWarnExtension` "AllowAmbiguousTypes"
 
     describe "Discouraged extensions" $ do
-      itWithOuter "ImplicitParams should warn" $ \output -> do
-        output `shouldSatisfy` containsWarning "ImplicitParams"
-
-      itWithOuter "UndecidableInstances should warn" $ \output -> do
-        output `shouldSatisfy` containsWarning "UndecidableInstances"
-
-runHlintOnSample :: IO Text
-runHlintOnSample = do
-  (exitCode, stdoutOutput, stderrOutput) <-
-    readProcess $
-      proc "hlint" ["test/HlintSamples/ExtensionDangerous.hs"]
-  pure $ case exitCode of
-    ExitSuccess -> convert stdoutOutput
-    ExitFailure _ -> convert stdoutOutput <> convert stderrOutput
+      itWithOuter "ImplicitParams should warn" $ \sample ->
+        sample `shouldWarnExtension` "ImplicitParams"
 
-containsWarning :: Text -> Text -> Bool
-containsWarning expectedMsg output = expectedMsg `T.isInfixOf` output
+      itWithOuter "UndecidableInstances should warn" $ \sample ->
+        sample `shouldWarnExtension` "UndecidableInstances"
diff --git a/test/HlintReexportSpec.hs b/test/HlintReexportSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintReexportSpec.hs
@@ -0,0 +1,241 @@
+module HlintReexportSpec (spec) where
+
+import Data.Set qualified as Set
+import Data.Text qualified as T
+import Himari
+import HlintRunner
+import Test.Syd
+
+spec :: Spec
+spec = do
+  describe "hlint rules for symbols re-exported through himari" $ do
+    describe "rules in .hlint.yaml" . beforeAll loadRestrictedFunctionNames $ do
+      itWithOuter "rules for Himari should be exactly the tested functions" $ \names ->
+        rulesThrough "Himari" names `shouldBe` reexportedFunctionNames
+
+      itWithOuter "rules for Himari.Prelude should be exactly the tested functions" $ \names ->
+        rulesThrough "Himari.Prelude" names `shouldBe` reexportedFunctionNames
+
+      itWithOuter "rules for Himari.SafePrelude should leave out the functions it lacks" $ \names ->
+        rulesThrough "Himari.SafePrelude" names
+          `shouldBe` (reexportedFunctionNames `Set.difference` preludeOnlyFunctionNames)
+
+    describe "import Himari" . withSample "ReexportHimari.hs" $ do
+      describe "every restricted function re-exported by Himari should warn" $ do
+        forM_ reexportedRestrictedFunctions $ \(declName, function, fragment) ->
+          itWithOuter (convert function <> " should warn with its own message") $ \sample ->
+            shouldWarnFunction sample declName function fragment
+
+      describe "functions restricted by a rule without a module name should warn" $ do
+        itWithOuter "throwString should warn" $ \sample ->
+          shouldWarnFunction sample "useThrowString" "throwString" "typed exceptions with throwM"
+
+      describe "functions of both Data.List and Data.Foldable should have a single message" $ do
+        itWithOuter "every function should be among the tested functions" $ \(_ :: Sample) ->
+          fmap snd listAndFoldableFunctions `shouldBe` listAndFoldableFunctionNames
+
+        forM_ listAndFoldableFunctions $ \(declName, function) ->
+          itWithOuter (convert function <> " should not have concatenated messages") $ \sample ->
+            shouldWarnFunctionOnce sample declName function "Partial:"
+
+      describe "total alternatives should NOT warn" $ do
+        itWithOuter "headMay should NOT warn" $ \sample ->
+          sample `shouldNotWarnFunctionIn` "useHeadMay"
+
+        itWithOuter "fromMaybe should NOT warn" $ \sample ->
+          sample `shouldNotWarnFunctionIn` "useFromMaybe"
+
+      describe "UnliftIO versions exported by Himari should NOT warn" $ do
+        forM_ unliftioDeclarations $ \declName ->
+          itWithOuter (convert declName <> " should NOT warn") $ \sample ->
+            sample `shouldNotWarnFunctionIn` declName
+
+    describe "import Himari.Prelude" . withSample "ReexportHimariPrelude.hs" $ do
+      itWithOuter "head should warn" $ \sample ->
+        shouldWarnFunction sample "useHead" "head" "headMay"
+
+      itWithOuter "foldl1 should warn with a single message" $ \sample ->
+        shouldWarnFunctionOnce sample "useFoldl1" "foldl1" "Partial:"
+
+      itWithOuter "bifoldl1 should warn" $ \sample ->
+        shouldWarnFunction sample "useBifoldl1" "bifoldl1" "bifoldl with a default value"
+
+      itWithOuter "fromJust should warn" $ \sample ->
+        shouldWarnFunction sample "useFromJust" "fromJust" "fromMaybe"
+
+      itWithOuter "readFile should warn" $ \sample ->
+        shouldWarnFunction sample "useReadFile" "readFile" "Lazy IO"
+
+      itWithOuter "singular should warn" $ \sample ->
+        shouldWarnFunction sample "useSingular" "singular" "(^?)"
+
+      itWithOuter "stringException should warn" $ \sample ->
+        shouldWarnFunction
+          sample
+          "useStringException"
+          "stringException"
+          "Define a proper exception type"
+
+      itWithOuter "headMay should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useHeadMay"
+
+      itWithOuter "catch of UnliftIO should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useCatch"
+
+    describe "import Himari.SafePrelude" . withSample "ReexportSafePrelude.hs" $ do
+      itWithOuter "head should warn" $ \sample ->
+        shouldWarnFunction sample "useHead" "head" "headMay"
+
+      itWithOuter "foldl1 should warn with a single message" $ \sample ->
+        shouldWarnFunctionOnce sample "useFoldl1" "foldl1" "Partial:"
+
+      itWithOuter "bifoldl1 should warn" $ \sample ->
+        shouldWarnFunction sample "useBifoldl1" "bifoldl1" "bifoldl with a default value"
+
+      itWithOuter "fromJust should warn" $ \sample ->
+        shouldWarnFunction sample "useFromJust" "fromJust" "fromMaybe"
+
+      itWithOuter "readFile should warn" $ \sample ->
+        shouldWarnFunction sample "useReadFile" "readFile" "Lazy IO"
+
+      itWithOuter "singular should warn" $ \sample ->
+        shouldWarnFunction sample "useSingular" "singular" "(^?)"
+
+      itWithOuter "headMay should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useHeadMay"
+
+    describe "import forms of Himari" . withSample "ReexportImportForms.hs" $ do
+      itWithOuter "head qualified with the alias of Himari should warn" $ \sample ->
+        shouldWarnFunction sample "useQualifiedHead" "H.head" "headMay"
+
+      itWithOuter "readFile qualified with the alias of Himari should warn" $ \sample ->
+        shouldWarnFunction sample "useQualifiedReadFile" "H.readFile" "Lazy IO"
+
+      itWithOuter "tail should warn even though other names are hidden" $ \sample ->
+        shouldWarnFunction sample "useTail" "tail" "tailMay"
+
+      itWithOuter "head of Data.List.NonEmpty should NOT warn when hidden from Himari" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useNonEmptyHead"
+
+      itWithOuter "head qualified with Data.List.NonEmpty should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useNonEmptyHeadQualified"
+
+      itWithOuter "definition of a user function named last should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "last"
+
+      itWithOuter "use of a user function named last should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useOwnLast"
+
+    describe "explicit import list of Himari" . withSample "ReexportExplicitImport.hs" $ do
+      itWithOuter "head should warn" $ \sample ->
+        shouldWarnFunction sample "useHead" "head" "headMay"
+
+      itWithOuter "readFile should warn" $ \sample ->
+        shouldWarnFunction sample "useReadFile" "readFile" "Lazy IO"
+
+      itWithOuter "headMay should NOT warn" $ \sample ->
+        sample `shouldNotWarnFunctionIn` "useHeadMay"
+
+-- | Module qualified names of the rules for the functions re-exported through the module.
+-- Rules for the modules below it, such as @Himari.Prelude.head@ for @Himari@, are left out.
+-- This does not support operators that contain a dot.
+rulesThrough :: Text -> [Text] -> Set.Set Text
+rulesThrough reexporter ruleNames =
+  Set.fromList
+    [ function
+    | ruleName <- ruleNames
+    , Just function <- [T.stripPrefix (reexporter <> ".") ruleName]
+    , not ("." `T.isInfixOf` function)
+    ]
+
+-- | Names of the functions in 'reexportedRestrictedFunctions'.
+reexportedFunctionNames :: Set.Set Text
+reexportedFunctionNames =
+  Set.fromList [function | (_, function, _) <- reexportedRestrictedFunctions]
+
+-- | Functions re-exported by "Himari.Prelude" but not by "Himari.SafePrelude".
+preludeOnlyFunctionNames :: Set.Set Text
+preludeOnlyFunctionNames = Set.fromList ["stringException"]
+
+-- | Declarations of the sample paired with the restricted function they use
+-- and a fragment of the message of its rule.
+-- These are all the functions that have a rule qualified with a module of himari in @.hlint.yaml@,
+-- which is verified against @.hlint.yaml@ by the tests.
+-- They are re-exported by "Himari" as the very same entity as the original one.
+reexportedRestrictedFunctions :: [(Text, Text, Text)]
+reexportedRestrictedFunctions =
+  [ ("useHead", "head", "headMay")
+  , ("useTail", "tail", "tailMay")
+  , ("useInit", "init", "initMay")
+  , ("useLast", "last", "lastMay")
+  , ("useCycle", "cycle", "cycleMay")
+  , ("useScanl1", "scanl1", "scanl1May")
+  , ("useScanr1", "scanr1", "scanr1May")
+  , ("useFoldl1", "foldl1", "foldl1May from Safe.Foldable")
+  , ("useFoldr1", "foldr1", "foldr1May from Safe.Foldable")
+  , ("useMaximum", "maximum", "maximumMay or maximumBound from Safe.Foldable")
+  , ("useMinimum", "minimum", "minimumMay or minimumBound from Safe.Foldable")
+  , ("useMaximumBy", "maximumBy", "maximumByMay or maximumBoundBy from Safe.Foldable")
+  , ("useMinimumBy", "minimumBy", "minimumByMay or minimumBoundBy from Safe.Foldable")
+  , ("useBifoldl1", "bifoldl1", "bifoldl with a default value")
+  , ("useBifoldr1", "bifoldr1", "bifoldr with a default value")
+  , ("useBimaximum", "bimaximum", "bifoldr with explicit initial value")
+  , ("useBiminimum", "biminimum", "bifoldr with explicit initial value")
+  , ("useBimaximumBy", "bimaximumBy", "bifoldr with explicit initial value")
+  , ("useBiminimumBy", "biminimumBy", "bifoldr with explicit initial value")
+  , ("useFromJust", "fromJust", "fromMaybe")
+  , ("useGetChar", "getChar", "Encoding depends on LANG")
+  , ("useGetLine", "getLine", "Encoding depends on LANG")
+  , ("useGetContents", "getContents", "Use strict Text or ByteString")
+  , ("useInteract", "interact", "Lazy IO + env-dependent encoding.")
+  , ("useReadIO", "readIO", "partial (uses read)")
+  , ("useReadLn", "readLn", "partial (uses read)")
+  , ("usePutChar", "putChar", "Encoding depends on LANG")
+  , ("usePutStr", "putStr", "Encoding depends on LANG")
+  , ("usePutStrLn", "putStrLn", "Encoding depends on LANG")
+  , ("usePrint", "print", "Encoding depends on LANG")
+  , ("useReadFile", "readFile", "Data.Text.IO.readFile")
+  , ("useWriteFile", "writeFile", "Data.Text.IO.writeFile")
+  , ("useAppendFile", "appendFile", "Data.Text.IO.appendFile")
+  , ("useSingular", "singular", "(^?)")
+  , ("useUnsafeSingular", "unsafeSingular", "0 or >1 elements")
+  , ("useUnsafePartsOf", "unsafePartsOf", "list length changes")
+  , ("useIunsafePartsOf", "iunsafePartsOf", "list length changes")
+  , ("useStringException", "stringException", "Define a proper exception type")
+  ]
+
+-- | Functions that both "Data.List" and "Data.Foldable" export as the very same entity.
+-- Both modules have a rule for them, so their messages are prone to be concatenated.
+-- The declarations that use them are looked up in 'reexportedRestrictedFunctions'.
+listAndFoldableFunctions :: [(Text, Text)]
+listAndFoldableFunctions =
+  [ (declName, function)
+  | (declName, function, _) <- reexportedRestrictedFunctions
+  , function `elem` listAndFoldableFunctionNames
+  ]
+
+-- | Names of the functions in 'listAndFoldableFunctions'.
+listAndFoldableFunctionNames :: [Text]
+listAndFoldableFunctionNames =
+  [ "foldl1"
+  , "foldr1"
+  , "maximum"
+  , "minimum"
+  , "maximumBy"
+  , "minimumBy"
+  ]
+
+-- | Declarations of the sample that use the UnliftIO version of a name
+-- whose non-UnliftIO version has a rule in @.hlint.yaml@.
+unliftioDeclarations :: [Text]
+unliftioDeclarations =
+  [ "useCatch"
+  , "useBracket"
+  , "useFinally"
+  , "useTry"
+  , "useWithMVar"
+  , "useModifyMVar"
+  , "useTimeout"
+  , "useMyThreadId"
+  , "useDoesFileExist"
+  ]
diff --git a/test/HlintRunner.hs b/test/HlintRunner.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintRunner.hs
@@ -0,0 +1,165 @@
+-- | Helpers to run hlint on a sample file and assert on its structured output.
+-- Assertions are keyed on declaration names instead of substrings of the whole output,
+-- so a warning for one declaration can never satisfy an expectation for another one.
+module HlintRunner
+  ( Sample
+  , withSample
+  , loadRestrictedFunctionNames
+  , shouldWarnFunction
+  , shouldWarnFunctionOnce
+  , shouldNotWarnFunctionIn
+  , shouldSuggestIn
+  , shouldWarnExtension
+  ) where
+
+import Data.Text qualified as T
+import Data.Text.IO qualified as T
+import Data.Yaml qualified as Yaml
+import Himari
+import Test.Syd
+
+-- | A single hint reported by @hlint --json@.
+data Idea = Idea
+  { decl :: [Text]
+  -- ^ Names of the declarations the hint belongs to.
+  , severity :: Text
+  -- ^ Severity of the hint. hlint reports a file it failed to parse as @Error@.
+  , hint :: Text
+  -- ^ Title of the hint such as @Avoid restricted function@.
+  , from :: Text
+  -- ^ Source fragment the hint points at.
+  , note :: [Text]
+  -- ^ Notes of the hint. The message of a restriction rule ends up here.
+  , startLine :: Int
+  }
+  deriving stock (Eq, Generic, Show)
+
+instance FromJSON Idea
+
+-- | A sample file together with the hints hlint reported for it.
+data Sample = Sample
+  { path :: FilePath
+  , source :: Text
+  , ideas :: [Idea]
+  }
+  deriving stock (Eq, Generic, Show)
+
+-- | Run hlint with the project's @.hlint.yaml@ on a sample file.
+-- hlint exits with a failure code when it reports hints, so the exit code is ignored.
+-- A sample hlint failed to parse is rejected here,
+-- because hlint reports nothing but the parse error for it
+-- and every negative expectation on it would pass without checking anything.
+loadSample :: FilePath -> IO Sample
+loadSample path = do
+  source <- T.readFile path
+  (_, stdoutOutput, stderrOutput) <- readProcess $ proc "hlint" ["--json", path]
+  case eitherDecode stdoutOutput of
+    Right ideas -> case filter (\idea -> idea.severity == "Error") ideas of
+      [] -> pure Sample{path, source, ideas}
+      errors ->
+        expectationFailure $
+          "hlint reported errors for " <> path <> ": " <> show errors
+    Left err ->
+      expectationFailure $
+        "failed to parse hlint output for "
+          <> path
+          <> ": "
+          <> err
+          <> "\n"
+          <> T.unpack (convert stderrOutput)
+
+-- | Run hlint once on a file of @test/HlintSamples@ and share the result among the tests.
+withSample :: FilePath -> TestDefM '[Sample] () () -> Spec
+withSample name = beforeAll (loadSample ("test/HlintSamples/" <> name))
+
+-- | A rule of @.hlint.yaml@.
+-- Only the function restrictions are read, the other kinds of rules have no @functions@ key.
+newtype Rule = Rule
+  { functions :: Maybe [FunctionRestriction]
+  }
+  deriving stock (Eq, Generic, Show)
+
+instance FromJSON Rule
+
+-- | A function restriction of @.hlint.yaml@.
+newtype FunctionRestriction = FunctionRestriction
+  { name :: Text
+  }
+  deriving stock (Eq, Generic, Show)
+
+instance FromJSON FunctionRestriction
+
+-- | Names of all the functions restricted by the project's @.hlint.yaml@.
+loadRestrictedFunctionNames :: IO [Text]
+loadRestrictedFunctionNames =
+  Yaml.decodeFileEither ".hlint.yaml" >>= \case
+    Right (rules :: [Rule]) ->
+      pure [restriction.name | rule <- rules, restriction <- fold rule.functions]
+    Left err ->
+      expectationFailure $
+        "failed to parse .hlint.yaml: " <> Yaml.prettyPrintParseException err
+
+-- | Fail unless the sample defines the declaration.
+-- This keeps negative expectations from passing vacuously
+-- when a declaration is renamed or removed from the sample.
+shouldDefine :: (HasCallStack) => Sample -> Text -> IO ()
+shouldDefine sample declName =
+  unless (any (T.isPrefixOf (declName <> " ::")) (T.lines sample.source)) . expectationFailure $
+    sample.path <> " does not define " <> T.unpack declName
+
+restrictedFunctionHint :: Text
+restrictedFunctionHint = "Avoid restricted function"
+
+-- | Restricted function warnings reported inside the declaration.
+restrictedFunctionsIn :: Text -> Sample -> [Idea]
+restrictedFunctionsIn declName sample =
+  filter (\idea -> idea.hint == restrictedFunctionHint && declName `elem` idea.decl) sample.ideas
+
+-- | Expect exactly one restricted function warning for the function inside the declaration.
+expectSingleWarning :: (HasCallStack) => Sample -> Text -> Text -> IO Idea
+expectSingleWarning sample declName function = do
+  sample `shouldDefine` declName
+  case filter (\idea -> idea.from == function) (restrictedFunctionsIn declName sample) of
+    [idea] -> pure idea
+    found ->
+      expectationFailure $
+        "expected exactly one restricted function warning for "
+          <> T.unpack function
+          <> " in "
+          <> T.unpack declName
+          <> ", but got "
+          <> show found
+
+-- | Expect the function used inside the declaration to be warned
+-- with a message that contains the fragment.
+shouldWarnFunction :: (HasCallStack) => Sample -> Text -> Text -> Text -> IO ()
+shouldWarnFunction sample declName function fragment = do
+  idea <- expectSingleWarning sample declName function
+  idea.note `shouldSatisfy` any (T.isInfixOf fragment)
+
+-- | Expect the function used inside the declaration to be warned with a single message.
+-- hlint concatenates the messages of all matching rules without any separator,
+-- so the message of a function matched by several rules contains the marker more than once.
+shouldWarnFunctionOnce :: (HasCallStack) => Sample -> Text -> Text -> Text -> IO ()
+shouldWarnFunctionOnce sample declName function marker = do
+  idea <- expectSingleWarning sample declName function
+  fmap (T.count marker) idea.note `shouldBe` [1]
+
+-- | Expect no restricted function warning inside the declaration.
+shouldNotWarnFunctionIn :: (HasCallStack) => Sample -> Text -> IO ()
+shouldNotWarnFunctionIn sample declName = do
+  sample `shouldDefine` declName
+  restrictedFunctionsIn declName sample `shouldBe` []
+
+-- | Expect a hint with the given title inside the declaration.
+shouldSuggestIn :: (HasCallStack) => Sample -> Text -> Text -> IO ()
+shouldSuggestIn sample declName hintTitle = do
+  sample `shouldDefine` declName
+  filter (\idea -> declName `elem` idea.decl) sample.ideas
+    `shouldSatisfy` any (\idea -> idea.hint == hintTitle)
+
+-- | Expect the language extension to be reported as restricted.
+shouldWarnExtension :: (HasCallStack) => Sample -> Text -> IO ()
+shouldWarnExtension sample extension =
+  filter (\idea -> idea.hint == "Avoid restricted extensions") sample.ideas
+    `shouldSatisfy` any (\idea -> ("LANGUAGE " <> extension <> " ") `T.isInfixOf` idea.from)
diff --git a/test/HlintSamples/ReexportExplicitImport.hs b/test/HlintSamples/ReexportExplicitImport.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintSamples/ReexportExplicitImport.hs
@@ -0,0 +1,18 @@
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
+-- Sample file to test that hlint rules match symbols imported from Himari
+-- with an explicit import list.
+module HlintSamples.ReexportExplicitImport where
+
+import Himari (IO, Int, Maybe, String, head, headMay, readFile)
+
+-- These should trigger warnings
+useHead :: [Int] -> Int
+useHead = head
+
+useReadFile :: IO String
+useReadFile = readFile "foo.txt"
+
+-- This should NOT trigger a warning
+useHeadMay :: [Int] -> Maybe Int
+useHeadMay = headMay
diff --git a/test/HlintSamples/ReexportHimari.hs b/test/HlintSamples/ReexportHimari.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintSamples/ReexportHimari.hs
@@ -0,0 +1,168 @@
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
+-- Sample file to test that hlint rules match symbols re-exported through Himari.
+-- Everything is used through a plain `import Himari`, which is the primary way to use himari.
+module HlintSamples.ReexportHimari where
+
+import Himari
+
+-- Data.List partial functions (should warn)
+useHead :: [Int] -> Int
+useHead = head
+
+useTail :: [Int] -> [Int]
+useTail = tail
+
+useInit :: [Int] -> [Int]
+useInit = init
+
+useLast :: [Int] -> Int
+useLast = last
+
+useCycle :: [Int] -> [Int]
+useCycle = cycle
+
+useScanl1 :: [Int] -> [Int]
+useScanl1 = scanl1 (+)
+
+useScanr1 :: [Int] -> [Int]
+useScanr1 = scanr1 (+)
+
+-- Data.Foldable partial functions (should warn)
+-- Data.List exports the very same entities, so the rules of both modules apply to them.
+useFoldl1 :: [Int] -> Int
+useFoldl1 = foldl1 (+)
+
+useFoldr1 :: [Int] -> Int
+useFoldr1 = foldr1 (+)
+
+useMaximum :: [Int] -> Int
+useMaximum = maximum
+
+useMinimum :: [Int] -> Int
+useMinimum = minimum
+
+useMaximumBy :: [Int] -> Int
+useMaximumBy = maximumBy (comparing negate)
+
+useMinimumBy :: [Int] -> Int
+useMinimumBy = minimumBy (comparing negate)
+
+-- Data.Bifoldable partial functions (should warn)
+useBifoldl1 :: (Int, Int) -> Int
+useBifoldl1 = bifoldl1 (+)
+
+useBifoldr1 :: (Int, Int) -> Int
+useBifoldr1 = bifoldr1 (+)
+
+useBimaximum :: (Int, Int) -> Int
+useBimaximum = bimaximum
+
+useBiminimum :: (Int, Int) -> Int
+useBiminimum = biminimum
+
+useBimaximumBy :: (Int, Int) -> Int
+useBimaximumBy = bimaximumBy (comparing negate)
+
+useBiminimumBy :: (Int, Int) -> Int
+useBiminimumBy = biminimumBy (comparing negate)
+
+-- Data.Maybe partial functions (should warn)
+useFromJust :: Maybe Int -> Int
+useFromJust = fromJust
+
+-- System.IO String IO functions (should warn)
+useGetChar :: IO Char
+useGetChar = getChar
+
+useGetLine :: IO String
+useGetLine = getLine
+
+useGetContents :: IO String
+useGetContents = getContents
+
+useInteract :: IO ()
+useInteract = interact id
+
+useReadIO :: IO Int
+useReadIO = readIO "1"
+
+useReadLn :: IO Int
+useReadLn = readLn
+
+usePutChar :: IO ()
+usePutChar = putChar 'a'
+
+usePutStr :: IO ()
+usePutStr = putStr "a"
+
+usePutStrLn :: IO ()
+usePutStrLn = putStrLn "a"
+
+usePrint :: IO ()
+usePrint = print (1 :: Int)
+
+useReadFile :: IO String
+useReadFile = readFile "foo.txt"
+
+useWriteFile :: IO ()
+useWriteFile = writeFile "foo.txt" "a"
+
+useAppendFile :: IO ()
+useAppendFile = appendFile "foo.txt" "a"
+
+-- Control.Lens.Traversal partial or unsafe functions (should warn)
+useSingular :: [Int] -> Int
+useSingular xs = xs ^. singular traverse
+
+useUnsafeSingular :: [Int] -> Int
+useUnsafeSingular xs = xs ^. unsafeSingular traverse
+
+useUnsafePartsOf :: [Int] -> [Int]
+useUnsafePartsOf xs = xs ^. unsafePartsOf traverse
+
+useIunsafePartsOf :: [Int] -> [Int]
+useIunsafePartsOf xs = xs ^. iunsafePartsOf traversed
+
+-- UnliftIO.Exception string exceptions (should warn)
+useThrowString :: IO ()
+useThrowString = throwString "a"
+
+useStringException :: StringException
+useStringException = stringException "a"
+
+-- Total alternatives (should NOT warn)
+useHeadMay :: [Int] -> Maybe Int
+useHeadMay = headMay
+
+useFromMaybe :: Maybe Int -> Int
+useFromMaybe = fromMaybe 0
+
+-- Himari exports the UnliftIO versions of these names, which are the recommended ones.
+-- The rules for the base versions of the same names must not apply to them (should NOT warn).
+useCatch :: IO ()
+useCatch = catch (pure ()) (\(_ :: IOException) -> pure ())
+
+useBracket :: IO ()
+useBracket = bracket (pure ()) (const (pure ())) (const (pure ()))
+
+useFinally :: IO ()
+useFinally = finally (pure ()) (pure ())
+
+useTry :: IO (Either IOException ())
+useTry = try (pure ())
+
+useWithMVar :: MVar () -> IO ()
+useWithMVar mv = withMVar mv pure
+
+useModifyMVar :: MVar () -> IO ()
+useModifyMVar mv = modifyMVar_ mv pure
+
+useTimeout :: IO (Maybe ())
+useTimeout = timeout 1000 (pure ())
+
+useMyThreadId :: IO ThreadId
+useMyThreadId = myThreadId
+
+useDoesFileExist :: IO Bool
+useDoesFileExist = doesFileExist "foo.txt"
diff --git a/test/HlintSamples/ReexportHimariPrelude.hs b/test/HlintSamples/ReexportHimariPrelude.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintSamples/ReexportHimariPrelude.hs
@@ -0,0 +1,36 @@
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
+-- Sample file to test that hlint rules match symbols re-exported through Himari.Prelude.
+-- Importing Himari.Prelude directly is needed inside himari itself to avoid import cycles.
+module HlintSamples.ReexportHimariPrelude where
+
+import Himari.Prelude
+
+-- These should trigger warnings
+useHead :: [Int] -> Int
+useHead = head
+
+useFoldl1 :: [Int] -> Int
+useFoldl1 = foldl1 (+)
+
+useBifoldl1 :: (Int, Int) -> Int
+useBifoldl1 = bifoldl1 (+)
+
+useFromJust :: Maybe Int -> Int
+useFromJust = fromJust
+
+useReadFile :: IO String
+useReadFile = readFile "foo.txt"
+
+useSingular :: [Int] -> Int
+useSingular xs = xs ^. singular traverse
+
+useStringException :: StringException
+useStringException = stringException "a"
+
+-- These should NOT trigger warnings
+useHeadMay :: [Int] -> Maybe Int
+useHeadMay = headMay
+
+useCatch :: IO ()
+useCatch = catch (pure ()) (\(_ :: IOException) -> pure ())
diff --git a/test/HlintSamples/ReexportImportForms.hs b/test/HlintSamples/ReexportImportForms.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintSamples/ReexportImportForms.hs
@@ -0,0 +1,37 @@
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
+-- Sample file to test how hlint rules for re-exported symbols interact with import forms.
+-- `head` and `last` are hidden from Himari,
+-- so those unqualified names refer to something else here.
+module HlintSamples.ReexportImportForms where
+
+import Data.List.NonEmpty (head)
+import Data.List.NonEmpty qualified as NE
+import Himari hiding (head, last)
+import Himari qualified as H
+
+-- Qualified use through Himari (should warn)
+useQualifiedHead :: [Int] -> Int
+useQualifiedHead = H.head
+
+useQualifiedReadFile :: IO String
+useQualifiedReadFile = H.readFile "foo.txt"
+
+-- Hiding some names does not hide the others (should warn)
+useTail :: [Int] -> [Int]
+useTail = tail
+
+-- `head` is the total one of Data.List.NonEmpty
+-- because the one of Himari is hidden (should NOT warn)
+useNonEmptyHead :: NonEmpty Int -> Int
+useNonEmptyHead = head
+
+useNonEmptyHeadQualified :: NonEmpty Int -> Int
+useNonEmptyHeadQualified = NE.head
+
+-- A total function defined by the user under the name hidden from Himari (should NOT warn)
+last :: [Int] -> Maybe Int
+last = lastMay
+
+useOwnLast :: [Int] -> Maybe Int
+useOwnLast = last
diff --git a/test/HlintSamples/ReexportSafePrelude.hs b/test/HlintSamples/ReexportSafePrelude.hs
new file mode 100644
--- /dev/null
+++ b/test/HlintSamples/ReexportSafePrelude.hs
@@ -0,0 +1,30 @@
+{-# OPTIONS_GHC -Wno-x-partial #-}
+
+-- Sample file to test that hlint rules match symbols re-exported through Himari.SafePrelude.
+-- Himari.SafePrelude is the subset of himari that can be imported under Safe Haskell.
+module HlintSamples.ReexportSafePrelude where
+
+import Himari.SafePrelude
+
+-- These should trigger warnings
+useHead :: [Int] -> Int
+useHead = head
+
+useFoldl1 :: [Int] -> Int
+useFoldl1 = foldl1 (+)
+
+useBifoldl1 :: (Int, Int) -> Int
+useBifoldl1 = bifoldl1 (+)
+
+useFromJust :: Maybe Int -> Int
+useFromJust = fromJust
+
+useReadFile :: IO String
+useReadFile = readFile "foo.txt"
+
+useSingular :: [Int] -> Int
+useSingular xs = xs ^. singular traverse
+
+-- These should NOT trigger warnings
+useHeadMay :: [Int] -> Maybe Int
+useHeadMay = headMay
diff --git a/test/HlintUnliftioSpec.hs b/test/HlintUnliftioSpec.hs
--- a/test/HlintUnliftioSpec.hs
+++ b/test/HlintUnliftioSpec.hs
@@ -1,45 +1,33 @@
 module HlintUnliftioSpec (spec) where
 
-import Data.Text qualified as T
 import Himari
+import HlintRunner
 import Test.Syd
 
 spec :: Spec
 spec = do
-  describe "hlint unliftio preference rules" . beforeAll runHlintOnSample $ do
+  describe "hlint unliftio preference rules" . withSample "UnliftioPreference.hs" $ do
     describe "Control" $ do
       describe "Exception" $ do
-        itWithOuter "catch should warn to use UnliftIO.Exception" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.Exception.catch"
+        itWithOuter "catch should warn to use UnliftIO.Exception" $ \sample ->
+          shouldWarnFunction sample "badCatch" "Exception.catch" "UnliftIO.Exception.catch"
 
-        itWithOuter "bracket should warn to use UnliftIO.Exception" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.Exception.bracket"
+        itWithOuter "bracket should warn to use UnliftIO.Exception" $ \sample ->
+          shouldWarnFunction sample "badBracket" "Exception.bracket" "UnliftIO.Exception.bracket"
 
-        itWithOuter "finally should warn to use UnliftIO.Exception" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.Exception.finally"
+        itWithOuter "finally should warn to use UnliftIO.Exception" $ \sample ->
+          shouldWarnFunction sample "badFinally" "Exception.finally" "UnliftIO.Exception.finally"
 
-        itWithOuter "try should warn to use UnliftIO.Exception" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.Exception.try"
+        itWithOuter "try should warn to use UnliftIO.Exception" $ \sample ->
+          shouldWarnFunction sample "badTry" "Exception.try" "UnliftIO.Exception.try"
 
       describe "Concurrent.MVar" $ do
-        itWithOuter "withMVar should warn to use UnliftIO.MVar" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.MVar.withMVar"
+        itWithOuter "withMVar should warn to use UnliftIO.MVar" $ \sample ->
+          shouldWarnFunction sample "badWithMVar" "MVar.withMVar" "UnliftIO.MVar.withMVar"
 
-        itWithOuter "modifyMVar_ should warn to use UnliftIO.MVar" $ \output -> do
-          output `shouldSatisfy` containsWarning "UnliftIO.MVar.modifyMVar_"
+        itWithOuter "modifyMVar_ should warn to use UnliftIO.MVar" $ \sample ->
+          shouldWarnFunction sample "badModifyMVar" "MVar.modifyMVar_" "UnliftIO.MVar.modifyMVar_"
 
     describe "System.Timeout" $ do
-      itWithOuter "timeout should warn to use UnliftIO.Timeout" $ \output -> do
-        output `shouldSatisfy` containsWarning "UnliftIO.Timeout.timeout"
-
-runHlintOnSample :: IO Text
-runHlintOnSample = do
-  (exitCode, stdoutOutput, stderrOutput) <-
-    readProcess $
-      proc "hlint" ["test/HlintSamples/UnliftioPreference.hs"]
-  pure $ case exitCode of
-    ExitSuccess -> convert stdoutOutput
-    ExitFailure _ -> convert stdoutOutput <> convert stderrOutput
-
-containsWarning :: Text -> Text -> Bool
-containsWarning expectedMsg output = expectedMsg `T.isInfixOf` output
+      itWithOuter "timeout should warn to use UnliftIO.Timeout" $ \sample ->
+        shouldWarnFunction sample "badTimeout" "Timeout.timeout" "UnliftIO.Timeout.timeout"
diff --git a/test/Main.hs b/test/Main.hs
--- a/test/Main.hs
+++ b/test/Main.hs
@@ -6,6 +6,7 @@
 import Himari.Prelude.FunctorSpec qualified as FunctorSpec
 import HlintBaseSpec qualified
 import HlintExtensionSpec qualified
+import HlintReexportSpec qualified
 import HlintUnliftioSpec qualified
 import Test.Syd
 import TitleSpec qualified
@@ -19,3 +20,4 @@
   describe "HlintUnliftio" HlintUnliftioSpec.spec
   describe "HlintBase" HlintBaseSpec.spec
   describe "HlintExtension" HlintExtensionSpec.spec
+  describe "HlintReexport" HlintReexportSpec.spec
