diff --git a/include/iris/x4/core/action.hpp b/include/iris/x4/core/action.hpp
index fba6c57ab..da408cb64 100644
--- a/include/iris/x4/core/action.hpp
+++ b/include/iris/x4/core/action.hpp
@@ -17,11 +17,12 @@
 #include <iris/x4/core/context.hpp>
 #include <iris/x4/core/action_context.hpp>
 
-#include <ranges>
+#include <ranges> // subrange
 #include <iterator>
 #include <concepts>
 #include <type_traits>
 #include <utility>
+#include <format>
 
 namespace iris::x4 {
 
@@ -109,6 +110,11 @@ struct action : proxy_parser<Subject, action<Subject, ActionF>>
 
     constexpr void operator[](auto const&) const = delete; // You can't add semantic action for semantic action
 
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format("{}[f]", get_info<Subject>{}(this->subject));
+    }
+
 private:
     // Semantic action with no parameter: `p[([] { /* ... */ })]`
     template<class Context, X4Attribute Attr>
diff --git a/include/iris/x4/core/skip_over.hpp b/include/iris/x4/core/skip_over.hpp
index 51a9f6eeb..83910a2d0 100644
--- a/include/iris/x4/core/skip_over.hpp
+++ b/include/iris/x4/core/skip_over.hpp
@@ -42,6 +42,25 @@ enum struct builtin_skipper_kind : char
     space,
 };
 
+namespace detail {
+
+template<builtin_skipper_kind Kind>
+struct builtin_skipper_traits;
+
+template<>
+struct builtin_skipper_traits<builtin_skipper_kind::blank>
+{
+    static constexpr char const* name = "blank";
+};
+
+template<>
+struct builtin_skipper_traits<builtin_skipper_kind::space>
+{
+    static constexpr char const* name = "space";
+};
+
+} // detail
+
 template<std::forward_iterator It, std::sentinel_for<It> Se, class Context>
     requires X4Subject<get_context_plain_t<contexts::skipper, Context>>
 constexpr void skip_over(It& first, Se const& last, Context const& ctx)
diff --git a/include/iris/x4/debug/print_attribute.hpp b/include/iris/x4/debug/print_attribute.hpp
index 650641993..97859dfd7 100644
--- a/include/iris/x4/debug/print_attribute.hpp
+++ b/include/iris/x4/debug/print_attribute.hpp
@@ -18,6 +18,7 @@
 #include <iris/rvariant/rvariant_io.hpp>
 
 #include <iris/alloy/utility.hpp>
+#include <iris/string.hpp>
 
 #ifdef IRIS_X4_UNICODE
 # include <iris/x4/char_encoding/unicode.hpp>
@@ -133,18 +134,23 @@ struct print_attribute_debug
         requires (!std::is_same_v<T_, unused_container_type>)
     static void call(std::ostream& out, T_ const& val)
     {
-        out << '[';
-        bool is_first = true;
-        auto last = traits::end(val);
-        for (auto it = traits::begin(val); it != last; ++it) {
-            if (is_first) {
-                is_first = false;
-            } else {
-                out << ", ";
+        if constexpr (iris::StringLike<T_>) {
+            out << std::basic_string_view{val};
+
+        } else {
+            out << '[';
+            bool is_first = true;
+            auto last = traits::end(val);
+            for (auto it = traits::begin(val); it != last; ++it) {
+                if (is_first) {
+                    is_first = false;
+                } else {
+                    out << ", ";
+                }
+                traits::print_attribute(out, *it);
             }
-            traits::print_attribute(out, *it);
+            out << ']';
         }
-        out << ']';
     }
 
     // for variant types
diff --git a/include/iris/x4/directive/lexeme.hpp b/include/iris/x4/directive/lexeme.hpp
index f14118091..d12dfc20f 100644
--- a/include/iris/x4/directive/lexeme.hpp
+++ b/include/iris/x4/directive/lexeme.hpp
@@ -14,6 +14,7 @@
 #include <iris/x4/core/skip_over.hpp>
 #include <iris/x4/core/parser.hpp>
 
+#include <format>
 #include <iterator>
 #include <type_traits>
 #include <utility>
@@ -43,6 +44,11 @@ struct lexeme_directive : proxy_parser<Subject, lexeme_directive<Subject>>
             attr
         );
     }
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format("lexeme[{}]", get_info<Subject>{}(this->subject));
+    }
 };
 
 namespace detail {
diff --git a/include/iris/x4/directive/skip.hpp b/include/iris/x4/directive/skip.hpp
index 2b788f5c6..83e10bf90 100644
--- a/include/iris/x4/directive/skip.hpp
+++ b/include/iris/x4/directive/skip.hpp
@@ -17,6 +17,7 @@
 
 #include <iris/x4/char/char_class_tags.hpp>
 
+#include <format>
 #include <concepts>
 #include <iterator>
 #include <type_traits>
@@ -49,6 +50,15 @@ struct skip_directive : proxy_parser<Subject, skip_directive<Subject, Skipper>>
         return this->subject.parse(first, last, x4::replace_first_context<contexts::skipper>(ctx, skipper_), attr);
     }
 
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format(
+            "skip({})[{}]",
+            get_info<Skipper>{}(this->skipper_),
+            get_info<Subject>{}(this->subject)
+        );
+    }
+
 private:
     template<class Context>
     using context_t = std::remove_cvref_t<decltype(
@@ -98,6 +108,15 @@ struct builtin_skip_directive : proxy_parser<Subject, builtin_skip_directive<Kin
         /* constexpr */ builtin_skipper_kind skipper_kind = Kind;
         return this->subject.parse(first, last, x4::replace_first_context<contexts::skipper>(ctx, skipper_kind), attr);
     }
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format(
+            "skip({})[{}]",
+            detail::builtin_skipper_traits<Kind>::name,
+            get_info<Subject>{}(this->subject)
+        );
+    }
 };
 
 
diff --git a/include/iris/x4/operator/alternative.hpp b/include/iris/x4/operator/alternative.hpp
index 2746a15e5..ca187c5c7 100644
--- a/include/iris/x4/operator/alternative.hpp
+++ b/include/iris/x4/operator/alternative.hpp
@@ -22,6 +22,7 @@
 
 #include <iris/rvariant/rvariant.hpp>
 
+#include <format>
 #include <concepts>
 #include <iterator>
 #include <type_traits>
@@ -211,6 +212,15 @@ struct alternative : binary_parser<Left, Right, alternative<Left, Right>>
         }
         return false; // `attr` is untouched
     }
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format(
+            "{} | {}",
+            get_info<Left>{}(this->left),
+            get_info<Right>{}(this->right)
+        );
+    }
 };
 
 template<X4Subject Left, X4Subject Right>
diff --git a/include/iris/x4/operator/list.hpp b/include/iris/x4/operator/list.hpp
index c6d9039b9..87646a504 100644
--- a/include/iris/x4/operator/list.hpp
+++ b/include/iris/x4/operator/list.hpp
@@ -19,6 +19,7 @@
 
 #include <iris/x4/traits/container_traits.hpp>
 
+#include <format>
 #include <iterator>
 #include <type_traits>
 #include <utility>
@@ -63,6 +64,15 @@ struct list : binary_parser<Left, Right, list<Left, Right>>
             return true;
         }
     }
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        return std::format(
+            "({} % {})",
+            get_info<Left>{}(this->left),
+            get_info<Right>{}(this->right)
+        );
+    }
 };
 
 template<X4Subject Left, X4Subject Right>
diff --git a/include/iris/x4/operator/sequence.hpp b/include/iris/x4/operator/sequence.hpp
index 67109b1a9..9d31d2550 100644
--- a/include/iris/x4/operator/sequence.hpp
+++ b/include/iris/x4/operator/sequence.hpp
@@ -20,7 +20,9 @@
 #include <iris/x4/directive/expect.hpp>
 
 #include <iris/alloy/tuple.hpp>
+#include <iris/type_traits.hpp>
 
+#include <format>
 #include <concepts>
 #include <iterator>
 #include <type_traits>
@@ -28,6 +30,9 @@
 
 namespace iris::x4 {
 
+template<class Subject>
+struct expect_directive;
+
 template<class Left, class Right>
 struct sequence : binary_parser<Left, Right, sequence<Left, Right>>
 {
@@ -73,6 +78,23 @@ struct sequence : binary_parser<Left, Right, sequence<Left, Right>>
     {
         return detail::parse_sequence(*this, first, last, ctx, attr);
     }
+
+    [[nodiscard]] constexpr std::string get_x4_info() const
+    {
+        if constexpr (iris::is_ttp_specialization_of_v<Right, expect_directive>) {
+            return std::format(
+                "{} > {}",
+                get_info<Left>{}(this->left),
+                get_info<typename Right::subject_type>{}(this->right.subject)
+            );
+        } else {
+            return std::format(
+                "{} >> {}",
+                get_info<Left>{}(this->left),
+                get_info<Right>{}(this->right)
+            );
+        }
+    }
 };
 
 template<X4Subject Left, X4Subject Right>
diff --git a/include/iris/x4/string/literal_string.hpp b/include/iris/x4/string/literal_string.hpp
index 848e5ed7a..54def7122 100644
--- a/include/iris/x4/string/literal_string.hpp
+++ b/include/iris/x4/string/literal_string.hpp
@@ -19,6 +19,7 @@
 #include <iris/x4/string/case_compare.hpp>
 #include <iris/x4/string/utf8.hpp>
 
+#include <format>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -75,7 +76,7 @@ struct get_info<literal_string<String, Encoding, Attr>>
     using result_type = std::string;
     [[nodiscard]] constexpr std::string operator()(literal_string<String, Encoding, Attr> const& p) const
     {
-        return '"' + x4::to_utf8(p.str) + '"';
+        return std::format("\"{}\"", p.str);
     }
 };
 
diff --git a/modules/iris b/modules/iris
index cec583eed..fe9e3a14d 160000
--- a/modules/iris
+++ b/modules/iris
@@ -1 +1 @@
-Subproject commit cec583eed7ab2fb70e7ef6aa52ab840bc03e92ca
+Subproject commit fe9e3a14dd412910b5a6dd6f14590bb6ced68ddc
diff --git a/test/x4/expect.cpp b/test/x4/expect.cpp
index 86fe5b483..7421940de 100644
--- a/test/x4/expect.cpp
+++ b/test/x4/expect.cpp
@@ -339,13 +339,11 @@ TEST_CASE("expect")
     #ifndef IRIS_X4_NO_RTTI
         X4_TEST_FAILURE("ay:a", char_ > char_('x') >> ':' > 'a',
         {
-            CHECK(x.which().find("sequence") != std::string::npos);
             CHECK(where == "y:a"sv);
         });
     #else
         X4_TEST_FAILURE("ay:a", char_ > char_('x') >> ':' > 'a',
         {
-            CHECK(which == "undefined"sv);
             CHECK(where == "y:a"sv);
         });
     #endif
@@ -418,23 +416,6 @@ TEST_CASE("expect")
         });
     }
 
-    //
-    // ********* Developers note **********
-    //
-    // As of now (see `git blame`), get_info<T> is still not
-    // specialized for many of the X4 parsers so that the
-    // value of `expectation_failure<...>::which()` will be
-    // implementation-defined demangled string.
-    // Therefore, it's essentially impossible to test them
-    // right now; further work must be done.
-    //
-    // Some specific situations are already been reported
-    // (e.g. https://github.com/boostorg/spirit/issues/777)
-    // but we really need to implement all specializations for
-    // X4's predefined parsers, not just the one reported above.
-    //
-
-
     // sanity check: test expectation_failure propagation
     // on custom skippers
     {