diff --git a/Cargo.lock b/Cargo.lock
index 0887dd143ed..dcbe9847936 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1399,6 +1399,7 @@ dependencies = [
  "gix-diff",
  "gix-dir",
  "gix-discover",
+ "gix-error",
  "gix-features",
  "gix-filter",
  "gix-fs",
@@ -1652,6 +1653,7 @@ version = "0.12.1"
 dependencies = [
  "bstr",
  "document-features",
+ "gix-error",
  "gix-hash",
  "gix-testtools",
  "itoa",
@@ -1659,7 +1661,6 @@ dependencies = [
  "pretty_assertions",
  "serde",
  "smallvec",
- "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -1747,6 +1748,14 @@ dependencies = [
  "thiserror 2.0.17",
 ]
 
+[[package]]
+name = "gix-error"
+version = "0.0.0"
+dependencies = [
+ "bstr",
+ "insta",
+]
+
 [[package]]
 name = "gix-features"
 version = "0.45.2"
@@ -2263,6 +2272,7 @@ name = "gix-refspec"
 version = "0.35.0"
 dependencies = [
  "bstr",
+ "gix-error",
  "gix-glob",
  "gix-hash",
  "gix-revision",
@@ -2282,6 +2292,7 @@ dependencies = [
  "document-features",
  "gix-commitgraph",
  "gix-date",
+ "gix-error",
  "gix-hash",
  "gix-hashtable",
  "gix-object",
@@ -2289,9 +2300,9 @@ dependencies = [
  "gix-revwalk",
  "gix-testtools",
  "gix-trace",
+ "insta",
  "permutohedron",
  "serde",
- "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -3064,9 +3075,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.45.0"
+version = "1.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b76866be74d68b1595eb8060cb9191dca9c021db2316558e52ddc5d55d41b66c"
+checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5"
 dependencies = [
  "console",
  "once_cell",
diff --git a/Cargo.toml b/Cargo.toml
index d6f4b9f73a9..45764bb57c0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -229,6 +229,7 @@ members = [
     "gix-trace",
     "gix-commitgraph",
     "gix-chunk",
+    "gix-error",
     "gix-quote",
     "gix-object",
     "gix-glob",
diff --git a/README.md b/README.md
index d7a09f3fa43..d5186327197 100644
--- a/README.md
+++ b/README.md
@@ -141,6 +141,7 @@ is usable to some extent.
   * [gix-dir](https://github.com/GitoxideLabs/gitoxide/blob/main/crate-status.md#gix-dir)
   * [gix-merge](https://github.com/GitoxideLabs/gitoxide/blob/main/crate-status.md#gix-merge)
   * [gix-shallow](https://github.com/GitoxideLabs/gitoxide/blob/main/crate-status.md#gix-shallow)
+  * [gix-error](https://github.com/GitoxideLabs/gitoxide/blob/main/crate-status.md#gix-error)
   * `gitoxide-core`
 * **very early**  _(possibly without any documentation and many rough edges)_
   * [gix-blame](https://github.com/GitoxideLabs/gitoxide/blob/main/crate-status.md#gix-blame)
diff --git a/crate-status.md b/crate-status.md
index e96aba59e1a..48cae911dc6 100644
--- a/crate-status.md
+++ b/crate-status.md
@@ -572,8 +572,12 @@ A mechanism to associate metadata with any object, and keep revisions of it usin
      - note that it's less critical to support it as `gitoxide` allows access but prevents untrusted configuration to become effective.
 
 ### gix-date
-* [ ] parse git dates
-* [ ] serialize `Time`
+* [x] parse git dates
+* [x] serialize `Time`
+
+### gix-error
+
+A basic crate for comon error types and utilities, changed as needed to replace `thiserror`.
 
 ### gix-credentials
 * [x] launch git credentials helpers with a given action
diff --git a/gitoxide-core/src/repository/diff.rs b/gitoxide-core/src/repository/diff.rs
index 0fe2a460f5b..3608508142c 100644
--- a/gitoxide-core/src/repository/diff.rs
+++ b/gitoxide-core/src/repository/diff.rs
@@ -125,15 +125,21 @@ fn resolve_revspec(
     let result = repo.rev_parse(revspec.as_bstr());
 
     match result {
-        Err(gix::revision::spec::parse::Error::FindReference(gix::refs::file::find::existing::Error::NotFound {
-            name,
-        })) => {
-            let root = repo.workdir().map(ToOwned::to_owned);
-            let name = gix::path::os_string_into_bstring(name.into())?;
-
-            Ok((ObjectId::null(gix::hash::Kind::Sha1), root, name))
+        Err(err) => {
+            // When the revspec is just a name, the delegate tries to resolve a reference which fails.
+            // We extract the error from the tree to learn the name, and treat it as file.
+            let not_found = err
+                .iter_frames()
+                .find_map(|f| f.downcast::<gix::refs::file::find::existing::Error>());
+            if let Some(gix::refs::file::find::existing::Error::NotFound { name }) = not_found {
+                let root = repo.workdir().map(ToOwned::to_owned);
+                let name = gix::path::os_string_into_bstring(name.into())?;
+
+                Ok((ObjectId::null(gix::hash::Kind::Sha1), root, name))
+            } else {
+                Err(err.into())
+            }
         }
-        Err(err) => Err(err.into()),
         Ok(resolved_revspec) => {
             let blob_id = resolved_revspec
                 .single()
diff --git a/gitoxide-core/src/repository/revision/explain.rs b/gitoxide-core/src/repository/revision/explain.rs
index 45e67427b48..04c4b41c02a 100644
--- a/gitoxide-core/src/repository/revision/explain.rs
+++ b/gitoxide-core/src/repository/revision/explain.rs
@@ -9,12 +9,13 @@ use gix::{
             Delegate,
         },
     },
+    Exn,
 };
 
 pub fn explain(spec: std::ffi::OsString, mut out: impl std::io::Write) -> anyhow::Result<()> {
     let mut explain = Explain::new(&mut out);
     let spec = gix::path::os_str_into_bstr(&spec)?;
-    gix::revision::plumbing::spec::parse(spec, &mut explain)?;
+    gix::revision::plumbing::spec::parse(spec, &mut explain).map_err(gix::Error::from)?;
     if let Some(err) = explain.err {
         bail!(err);
     }
@@ -41,9 +42,10 @@ impl<'a> Explain<'a> {
             err: None,
         }
     }
-    fn prefix(&mut self) -> Option<()> {
+    fn prefix(&mut self) -> Result<(), Exn> {
         self.call += 1;
-        write!(self.out, "{:02}. ", self.call).ok()
+        write!(self.out, "{:02}. ", self.call).ok();
+        Ok(())
     }
     fn revision_name(&self) -> BString {
         self.ref_name.clone().unwrap_or_else(|| {
@@ -56,13 +58,18 @@ impl<'a> Explain<'a> {
 }
 
 impl delegate::Revision for Explain<'_> {
-    fn find_ref(&mut self, name: &BStr) -> Option<()> {
+    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
         self.prefix()?;
         self.ref_name = Some(name.into());
-        writeln!(self.out, "Lookup the '{name}' reference").ok()
+        writeln!(self.out, "Lookup the '{name}' reference").ok();
+        Ok(())
     }
 
-    fn disambiguate_prefix(&mut self, prefix: gix::hash::Prefix, hint: Option<delegate::PrefixHint<'_>>) -> Option<()> {
+    fn disambiguate_prefix(
+        &mut self,
+        prefix: gix::hash::Prefix,
+        hint: Option<delegate::PrefixHint<'_>>,
+    ) -> Result<(), Exn> {
         self.prefix()?;
         self.oid_prefix = Some(prefix);
         writeln!(
@@ -76,10 +83,11 @@ impl delegate::Revision for Explain<'_> {
                     format!("commit {generation} generations in future of reference {ref_name:?}"),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 
-    fn reflog(&mut self, query: ReflogLookup) -> Option<()> {
+    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn> {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let ref_name: &BStr = self.ref_name.as_ref().map_or_else(|| "HEAD".into(), AsRef::as_ref);
@@ -92,16 +100,18 @@ impl delegate::Revision for Explain<'_> {
                 ref_name
             )
             .ok(),
-        }
+        };
+        Ok(())
     }
 
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Option<()> {
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
         self.prefix()?;
         self.has_implicit_anchor = true;
-        writeln!(self.out, "Find the {branch_no}th checked-out branch of 'HEAD'").ok()
+        writeln!(self.out, "Find the {branch_no}th checked-out branch of 'HEAD'").ok();
+        Ok(())
     }
 
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Option<()> {
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn> {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let ref_info = match self.ref_name.as_ref() {
@@ -117,12 +127,13 @@ impl delegate::Revision for Explain<'_> {
             },
             ref_info
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 }
 
 impl delegate::Navigate for Explain<'_> {
-    fn traverse(&mut self, kind: Traversal) -> Option<()> {
+    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn> {
         self.prefix()?;
         let name = self.revision_name();
         writeln!(
@@ -133,10 +144,11 @@ impl delegate::Navigate for Explain<'_> {
                 Traversal::NthParent(no) => format!("Select the {no}. parent of revision named '{name}'"),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Option<()> {
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn> {
         self.prefix()?;
         writeln!(
             self.out,
@@ -148,10 +160,11 @@ impl delegate::Navigate for Explain<'_> {
                 PeelTo::Path(path) => format!("Lookup the object at '{path}' from the current tree-ish"),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Option<()> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
         self.prefix()?;
         self.has_implicit_anchor = true;
         let negate_text = if negated { "does not match" } else { "matches" };
@@ -172,10 +185,11 @@ impl delegate::Navigate for Explain<'_> {
                 ),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
         self.prefix()?;
         self.has_implicit_anchor = true;
         writeln!(
@@ -190,12 +204,13 @@ impl delegate::Navigate for Explain<'_> {
                 _ => unreachable!("BUG: parser assures of that"),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 }
 
 impl delegate::Kind for Explain<'_> {
-    fn kind(&mut self, kind: spec::Kind) -> Option<()> {
+    fn kind(&mut self, kind: spec::Kind) -> Result<(), Exn> {
         self.prefix()?;
         self.call = 0;
         writeln!(
@@ -211,14 +226,16 @@ impl delegate::Kind for Explain<'_> {
                     unreachable!("BUG: 'single' mode is implied but cannot be set explicitly"),
             }
         )
-        .ok()
+        .ok();
+        Ok(())
     }
 }
 
 impl Delegate for Explain<'_> {
-    fn done(&mut self) {
+    fn done(&mut self) -> Result<(), Exn> {
         if !self.has_implicit_anchor && self.ref_name.is_none() && self.oid_prefix.is_none() {
             self.err = Some("Incomplete specification lacks its anchor, like a reference or object name".into());
         }
+        Ok(())
     }
 }
diff --git a/gix-actor/src/signature/mod.rs b/gix-actor/src/signature/mod.rs
index 6641b10de57..83063b7b622 100644
--- a/gix-actor/src/signature/mod.rs
+++ b/gix-actor/src/signature/mod.rs
@@ -15,7 +15,7 @@ mod _ref {
         }
 
         /// Try to parse the timestamp and create an owned instance from this shared one.
-        pub fn to_owned(&self) -> Result<Signature, gix_date::parse::Error> {
+        pub fn to_owned(&self) -> Result<Signature, gix_date::Error> {
             Ok(Signature {
                 name: self.name.to_owned(),
                 email: self.email.to_owned(),
@@ -58,7 +58,7 @@ mod _ref {
 
         /// Parse the `time` field for access to the passed time since unix epoch, and the time offset.
         /// The format is expected to be [raw](gix_date::parse_header()).
-        pub fn time(&self) -> Result<gix_date::Time, gix_date::parse::Error> {
+        pub fn time(&self) -> Result<gix_date::Time, gix_date::Error> {
             self.time.parse()
         }
     }
diff --git a/gix-blame/tests/blame.rs b/gix-blame/tests/blame.rs
index 3b404a96153..188e02c9470 100644
--- a/gix-blame/tests/blame.rs
+++ b/gix-blame/tests/blame.rs
@@ -398,7 +398,9 @@ fn since() -> gix_testtools::Result {
         gix_blame::Options {
             diff_algorithm: gix_diff::blob::Algorithm::Histogram,
             ranges: BlameRanges::default(),
-            since: Some(gix_date::parse("2025-01-31", None)?),
+            since: Some(
+                gix_date::parse("2025-01-31", None).expect("TODO: should be able to to retrieve inner from Exn"),
+            ),
             rewrites: Some(gix_diff::Rewrites::default()),
             debug_track_path: false,
         },
diff --git a/gix-date/Cargo.toml b/gix-date/Cargo.toml
index 45c1ef1b9f0..cd7db662d52 100644
--- a/gix-date/Cargo.toml
+++ b/gix-date/Cargo.toml
@@ -19,11 +19,11 @@ doctest = false
 serde = ["dep:serde", "bstr/serde"]
 
 [dependencies]
+gix-error = { version = "0.0.0", path = "../gix-error" }
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 itoa = "1.0.17"
 jiff = "0.2.17"
-thiserror = "2.0.17"
 # TODO: used for quick and easy `TimeBacking: std::io::Write` implementation, but could make that `Copy`
 #       and remove this dep with custom impl
 smallvec = { version = "1.15.1", features = ["write"] }
diff --git a/gix-date/src/lib.rs b/gix-date/src/lib.rs
index c0471b42e8a..7c94a10039a 100644
--- a/gix-date/src/lib.rs
+++ b/gix-date/src/lib.rs
@@ -15,6 +15,8 @@ pub mod time;
 pub mod parse;
 pub use parse::function::{parse, parse_header};
 
+pub use gix_error::ParseError as Error;
+
 /// A timestamp with timezone.
 #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/gix-date/src/parse/function.rs b/gix-date/src/parse/function.rs
index 00b000be4d2..8051017bd0b 100644
--- a/gix-date/src/parse/function.rs
+++ b/gix-date/src/parse/function.rs
@@ -5,10 +5,11 @@ use jiff::{civil::Date, fmt::rfc2822, tz::TimeZone, Zoned};
 use crate::parse::git::parse_git_date_format;
 use crate::parse::raw::parse_raw;
 use crate::{
-    parse::{relative, Error},
+    parse::relative,
     time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
-    OffsetInSeconds, SecondsSinceUnixEpoch, Time,
+    Error, OffsetInSeconds, SecondsSinceUnixEpoch, Time,
 };
+use gix_error::{Exn, ResultExt};
 
 /// Parse `input` as any time that Git can parse when inputting a date.
 ///
@@ -71,11 +72,11 @@ use crate::{
 /// If `now` is October 27, 2023 at 10:00:00 UTC:
 ///     *   `2 minutes ago` (October 27, 2023 at 09:58:00 UTC)
 ///     *   `3 hours ago` (October 27, 2023 at 07:00:00 UTC)
-pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
+pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Exn<Error>> {
     Ok(if let Ok(val) = Date::strptime(SHORT.0, input) {
         let val = val
             .to_zoned(TimeZone::UTC)
-            .map_err(|_| Error::InvalidDateString { input: input.into() })?;
+            .or_raise(|| Error::new_with_input("Timezone conversion failed", input))?;
         Time::new(val.timestamp().as_second(), val.offset().seconds())
     } else if let Ok(val) = rfc2822_relaxed(input) {
         Time::new(val.timestamp().as_second(), val.offset().seconds())
@@ -97,7 +98,7 @@ pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
         // Format::Raw
         val
     } else {
-        return Err(Error::InvalidDateString { input: input.into() });
+        return Err(Error::new_with_input("Unknown date format", input))?;
     })
 }
 
@@ -168,7 +169,7 @@ pub fn parse_header(input: &str) -> Option<Time> {
 /// whose weekdays are inconsistent with the date. While the day-of-week
 /// still must be parsed, it is otherwise ignored. This seems to be
 /// consistent with how `git` behaves.
-fn strptime_relaxed(fmt: &str, input: &str) -> Result<Zoned, jiff::Error> {
+fn strptime_relaxed(fmt: &str, input: &str) -> std::result::Result<Zoned, jiff::Error> {
     let mut tm = jiff::fmt::strtime::parse(fmt, input)?;
     tm.set_weekday(None);
     tm.to_zoned()
@@ -176,7 +177,7 @@ fn strptime_relaxed(fmt: &str, input: &str) -> Result<Zoned, jiff::Error> {
 
 /// This is just like strptime_relaxed, except for RFC 2822 parsing.
 /// Namely, it permits the weekday to be inconsistent with the date.
-fn rfc2822_relaxed(input: &str) -> Result<Zoned, jiff::Error> {
+fn rfc2822_relaxed(input: &str) -> std::result::Result<Zoned, jiff::Error> {
     static P: rfc2822::DateTimeParser = rfc2822::DateTimeParser::new().relaxed_weekday(true);
     P.parse_zoned(input)
 }
diff --git a/gix-date/src/parse/mod.rs b/gix-date/src/parse/mod.rs
index 33b8a9a8610..cf8df177734 100644
--- a/gix-date/src/parse/mod.rs
+++ b/gix-date/src/parse/mod.rs
@@ -1,22 +1,8 @@
 use std::str::FromStr;
 
+use crate::{Error, Time};
 use smallvec::SmallVec;
 
-use crate::Time;
-
-#[derive(thiserror::Error, Debug, Clone)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("Could not convert a duration into a date")]
-    RelativeTimeConversion,
-    #[error("Date string can not be parsed")]
-    InvalidDateString { input: String },
-    #[error("The heat-death of the universe happens before this date")]
-    InvalidDate(#[from] std::num::TryFromIntError),
-    #[error("Current time is missing but required to handle relative dates.")]
-    MissingCurrentTime,
-}
-
 /// A container for just enough bytes to hold the largest-possible [`time`](Time) instance.
 /// It's used in conjunction with
 #[derive(Default, Clone)]
@@ -58,7 +44,7 @@ impl FromStr for Time {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        crate::parse_header(s).ok_or_else(|| Error::InvalidDateString { input: s.into() })
+        crate::parse_header(s).ok_or_else(|| Error::new_with_input("invalid time", s))
     }
 }
 
diff --git a/gix-date/src/parse/relative.rs b/gix-date/src/parse/relative.rs
index 2000707d984..e6daabbda8a 100644
--- a/gix-date/src/parse/relative.rs
+++ b/gix-date/src/parse/relative.rs
@@ -1,10 +1,10 @@
 use std::{str::FromStr, time::SystemTime};
 
+use crate::Error;
+use gix_error::{ensure, Exn, ParseError, ResultExt};
 use jiff::{tz::TimeZone, Span, Timestamp, Zoned};
 
-use crate::parse::Error;
-
-fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
+fn parse_inner(input: &str) -> Option<Result<Span, Exn<Error>>> {
     let mut split = input.split_whitespace();
     let units = i64::from_str(split.next()?).ok()?;
     let period = split.next()?;
@@ -14,31 +14,29 @@ fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
     span(period, units)
 }
 
-pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error>> {
-    parse_inner(input).map(|result| {
+pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Exn<Error>>> {
+    parse_inner(input).map(|result| -> Result<Zoned, Exn<Error>> {
         let span = result?;
         // This was an error case in a previous version of this code, where
         // it would fail when converting from a negative signed integer
         // to an unsigned integer. This preserves that failure case even
         // though the code below handles it okay.
-        if span.is_negative() {
-            return Err(Error::RelativeTimeConversion);
-        }
-        now.ok_or(Error::MissingCurrentTime).and_then(|now| {
-            let ts = Timestamp::try_from(now).map_err(|_| Error::RelativeTimeConversion)?;
-            // N.B. This matches the behavior of this code when it was
-            // written with `time`, but we might consider using the system
-            // time zone here. If we did, then it would implement "1 day
-            // ago" correctly, even when it crosses DST transitions. Since
-            // we're in the UTC time zone here, which has no DST, 1 day is
-            // in practice always 24 hours. ---AG
-            let zdt = ts.to_zoned(TimeZone::UTC);
-            zdt.checked_sub(span).map_err(|_| Error::RelativeTimeConversion)
-        })
+        ensure!(!span.is_negative(), ParseError::new(""));
+        let now = now.ok_or(ParseError::new("Missing current time"))?;
+        let ts: Timestamp = Timestamp::try_from(now).or_raise(|| Error::new("Could not convert current time"))?;
+        // N.B. This matches the behavior of this code when it was
+        // written with `time`, but we might consider using the system
+        // time zone here. If we did, then it would implement "1 day
+        // ago" correctly, even when it crosses DST transitions. Since
+        // we're in the UTC time zone here, which has no DST, 1 day is
+        // in practice always 24 hours. ---AG
+        let zdt = ts.to_zoned(TimeZone::UTC);
+        zdt.checked_sub(span)
+            .or_raise(|| Error::new(format!("Failed to subtract {zdt} from {span}")))
     })
 }
 
-fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
+fn span(period: &str, units: i64) -> Option<Result<Span, Exn<Error>>> {
     let period = period.strip_suffix('s').unwrap_or(period);
     let result = match period {
         "second" => Span::new().try_seconds(units),
@@ -51,7 +49,7 @@ fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
         // Ignore values you don't know, assume seconds then (so does git)
         _anything => Span::new().try_seconds(units),
     };
-    Some(result.map_err(|_| Error::RelativeTimeConversion))
+    Some(result.or_raise(|| Error::new(format!("Couldn't parse span from '{period} {units}'"))))
 }
 
 #[cfg(test)]
diff --git a/gix-date/tests/time/parse/mod.rs b/gix-date/tests/time/parse/mod.rs
index f8a5f858c15..075430a6f1a 100644
--- a/gix-date/tests/time/parse/mod.rs
+++ b/gix-date/tests/time/parse/mod.rs
@@ -1,6 +1,7 @@
 use std::time::SystemTime;
 
 use gix_date::Time;
+use gix_error::Exn;
 
 #[test]
 fn time_without_offset_defaults_to_utc() {
@@ -63,7 +64,7 @@ fn git_rfc2822() {
 }
 
 #[test]
-fn raw() -> gix_testtools::Result {
+fn raw() -> Result<(), Exn<gix_date::Error>> {
     assert_eq!(
         gix_date::parse("1660874655 +0800", None)?,
         Time {
@@ -177,10 +178,10 @@ fn git_default() {
 
 #[test]
 fn invalid_dates_can_be_produced_without_current_time() {
-    assert!(matches!(
-        gix_date::parse("foobar", None).unwrap_err(),
-        gix_date::parse::Error::InvalidDateString { input } if input == "foobar"
-    ));
+    assert_eq!(
+        gix_date::parse("foobar", None).unwrap_err().to_string(),
+        "Unknown date format: foobar"
+    );
 }
 
 /// Tests for compact ISO8601 formats (YYYYMMDDTHHMMSS variants)
diff --git a/gix-date/tests/time/parse/relative.rs b/gix-date/tests/time/parse/relative.rs
index c0206907c52..ae3799dec70 100644
--- a/gix-date/tests/time/parse/relative.rs
+++ b/gix-date/tests/time/parse/relative.rs
@@ -10,10 +10,12 @@ fn large_offsets() {
 
 #[test]
 fn large_offsets_do_not_panic() {
-    assert!(matches!(
-        gix_date::parse("9999999999 weeks ago", Some(std::time::UNIX_EPOCH)),
-        Err(gix_date::parse::Error::RelativeTimeConversion)
-    ));
+    assert_eq!(
+        gix_date::parse("9999999999 weeks ago", Some(std::time::UNIX_EPOCH))
+            .unwrap_err()
+            .to_string(),
+        "Couldn't parse span from 'week 9999999999'"
+    );
 }
 
 #[test]
diff --git a/gix-error/Cargo.toml b/gix-error/Cargo.toml
new file mode 100644
index 00000000000..8d05c1a34ce
--- /dev/null
+++ b/gix-error/Cargo.toml
@@ -0,0 +1,19 @@
+lints.workspace = true
+
+[package]
+name = "gix-error"
+version = "0.0.0"
+repository = "https://github.com/GitoxideLabs/gitoxide"
+license = "MIT OR Apache-2.0"
+description = "A crate of the gitoxide project to provide common errors and error-handling utilities"
+authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
+edition = "2021"
+include = ["src/**/*", "LICENSE-*"]
+rust-version = "1.82"
+
+[dependencies]
+bstr = { version = "1.12.0", default-features = false, features = ["std"] }
+
+[dev-dependencies]
+insta = "1.46.0"
+
diff --git a/gix-error/LICENSE-APACHE b/gix-error/LICENSE-APACHE
new file mode 120000
index 00000000000..965b606f331
--- /dev/null
+++ b/gix-error/LICENSE-APACHE
@@ -0,0 +1 @@
+../LICENSE-APACHE
\ No newline at end of file
diff --git a/gix-error/LICENSE-MIT b/gix-error/LICENSE-MIT
new file mode 120000
index 00000000000..76219eb72e8
--- /dev/null
+++ b/gix-error/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
\ No newline at end of file
diff --git a/gix-error/src/error.rs b/gix-error/src/error.rs
new file mode 100644
index 00000000000..c0789911347
--- /dev/null
+++ b/gix-error/src/error.rs
@@ -0,0 +1,80 @@
+use crate::{exn, Error, Exn};
+use std::fmt::Formatter;
+
+/// Utilities
+impl Error {
+    /// Return the error that is most likely the root cause, based on heuristics.
+    /// Note that if there is nothing but this error, i.e. no source or children, this error is returned.
+    pub fn probable_cause(&self) -> &(dyn std::error::Error + 'static) {
+        let root = self.inner.as_frame();
+        root.probable_cause().unwrap_or(root).as_error()
+    }
+
+    /// Return an iterator over all errors in the tree in breadth-first order, starting with this one.
+    pub fn iter_frames(&self) -> impl Iterator<Item = &exn::Frame> + '_ {
+        self.inner.as_frame().iter()
+    }
+}
+
+pub(super) enum Inner {
+    ExnAsError(Box<exn::Frame>),
+    Exn(Box<exn::Frame>),
+}
+
+impl Inner {
+    fn as_frame(&self) -> &exn::Frame {
+        match self {
+            Inner::ExnAsError(f) | Inner::Exn(f) => f,
+        }
+    }
+}
+
+impl Error {
+    /// Create a new instance representing the given `error`.
+    #[track_caller]
+    pub fn from_error(error: impl std::error::Error + Send + Sync + 'static) -> Self {
+        Error {
+            inner: Inner::ExnAsError(Exn::new(error).into()),
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            Inner::ExnAsError(err) => std::fmt::Display::fmt(err.as_error(), f),
+            Inner::Exn(frame) => std::fmt::Display::fmt(frame, f),
+        }
+    }
+}
+
+impl std::fmt::Debug for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match &self.inner {
+            Inner::ExnAsError(err) => std::fmt::Debug::fmt(err.as_error(), f),
+            Inner::Exn(frame) => std::fmt::Debug::fmt(frame, f),
+        }
+    }
+}
+
+impl std::error::Error for Error {
+    /// Return the first source of an [Exn] error, or the source of a boxed error.
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            Inner::ExnAsError(frame) | Inner::Exn(frame) => {
+                frame.children().first().map(exn::Frame::as_error_no_send_sync)
+            }
+        }
+    }
+}
+
+impl<E> From<Exn<E>> for Error
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    fn from(err: Exn<E>) -> Self {
+        Error {
+            inner: Inner::Exn(err.into()),
+        }
+    }
+}
diff --git a/gix-error/src/exn/ext.rs b/gix-error/src/exn/ext.rs
new file mode 100644
index 00000000000..e326d8daa6e
--- /dev/null
+++ b/gix-error/src/exn/ext.rs
@@ -0,0 +1,198 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::exn::Exn;
+use std::error::Error;
+
+/// A trait bound of the supported error type of [`Exn`].
+pub trait ErrorExt: std::error::Error + Send + Sync + 'static {
+    /// Raise this error as a new exception.
+    #[track_caller]
+    fn raise(self) -> Exn<Self>
+    where
+        Self: Sized,
+    {
+        Exn::new(self)
+    }
+
+    /// Raise this error as a new exception, with type erasure.
+    #[track_caller]
+    fn erased(self) -> Exn
+    where
+        Self: Sized,
+    {
+        Exn::new(self).erased()
+    }
+
+    /// Raise this error as a new exception, with `sources` as causes.
+    #[track_caller]
+    fn raise_iter<T, I>(self, sources: I) -> Exn<Self>
+    where
+        Self: Sized,
+        T: std::error::Error + Send + Sync + 'static,
+        I: IntoIterator,
+        I::Item: Into<Exn<T>>,
+    {
+        Exn::from_iter(sources, self)
+    }
+}
+
+impl<T> ErrorExt for T where T: std::error::Error + Send + Sync + 'static {}
+
+/// An extension trait for [`Option`] to provide raising new exceptions on `None`.
+pub trait OptionExt {
+    /// The `Some` type.
+    type Some;
+
+    /// Construct a new [`Exn`] on the `None` variant.
+    fn ok_or_raise<A, F>(self, err: F) -> Result<Self::Some, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+
+    /// Construct a new [`Exn`] on the `None` variant, with type erasure.
+    fn ok_or_raise_erased<A, F>(self, err: F) -> Result<Self::Some, Exn>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+}
+
+impl<T> OptionExt for Option<T> {
+    type Some = T;
+
+    #[track_caller]
+    fn ok_or_raise<A, F>(self, err: F) -> Result<T, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Some(v) => Ok(v),
+            None => Err(Exn::new(err())),
+        }
+    }
+
+    #[track_caller]
+    fn ok_or_raise_erased<A, F>(self, err: F) -> Result<T, Exn>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        self.ok_or_raise(err).map_err(Exn::erased)
+    }
+}
+
+/// An extension trait for [`Result`] to provide context information on [`Exn`]s.
+pub trait ResultExt {
+    /// The `Ok` type.
+    type Success;
+
+    /// The `Err` type that would be wrapped in an [`Exn`].
+    type Error: std::error::Error + Send + Sync + 'static;
+
+    /// Raise a new exception on the [`Exn`] inside the [`Result`].
+    ///
+    /// Apply [`Exn::raise`] on the `Err` variant, refer to it for more information.
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+
+    /// Raise a new exception on the [`Exn`] inside the [`Result`], but erase its type.
+    ///
+    /// Apply [`Exn::erased`] on the `Err` variant, refer to it for more information.
+    fn or_erased(self) -> Result<Self::Success, Exn>;
+
+    /// Raise a new exception on the [`Exn`] inside the [`Result`], and type-erase the result.
+    ///
+    /// Apply [`Exn::raise`] and [`Exn::erased`] on the `Err` variant, refer to it for more information.
+    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A;
+}
+
+impl<T, E> ResultExt for std::result::Result<T, E>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    type Success = T;
+    type Error = E;
+
+    #[track_caller]
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(Exn::new(e).raise(err())),
+        }
+    }
+
+    #[track_caller]
+    fn or_erased(self) -> Result<Self::Success, Exn> {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(Exn::new(e).erased()),
+        }
+    }
+
+    #[track_caller]
+    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    where
+        A: Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        self.or_raise(err).map_err(Exn::erased)
+    }
+}
+
+impl<T, E> ResultExt for std::result::Result<T, Exn<E>>
+where
+    E: std::error::Error + Send + Sync + 'static,
+{
+    type Success = T;
+    type Error = E;
+
+    #[track_caller]
+    fn or_raise<A, F>(self, err: F) -> Result<Self::Success, Exn<A>>
+    where
+        A: std::error::Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(e.raise(err())),
+        }
+    }
+
+    #[track_caller]
+    fn or_erased(self) -> Result<Self::Success, Exn> {
+        match self {
+            Ok(v) => Ok(v),
+            Err(e) => Err(e.erased()),
+        }
+    }
+
+    #[track_caller]
+    fn or_raise_erased<A, F>(self, err: F) -> Result<Self::Success, Exn>
+    where
+        A: Error + Send + Sync + 'static,
+        F: FnOnce() -> A,
+    {
+        self.or_raise(err).map_err(Exn::erased)
+    }
+}
diff --git a/gix-error/src/exn/impls.rs b/gix-error/src/exn/impls.rs
new file mode 100644
index 00000000000..6d39a371ef8
--- /dev/null
+++ b/gix-error/src/exn/impls.rs
@@ -0,0 +1,485 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::error::Error;
+use std::fmt;
+use std::fmt::Formatter;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::panic::Location;
+
+use crate::Exn;
+
+impl<E: Error + Send + Sync + 'static> From<E> for Exn<E> {
+    #[track_caller]
+    fn from(error: E) -> Self {
+        Exn::new(error)
+    }
+}
+
+impl<E: Error + Send + Sync + 'static> Exn<E> {
+    /// Create a new exception with the given error.
+    ///
+    /// This will automatically walk the [source chain of the error] and add them as children
+    /// frames.
+    ///
+    /// See also [`ErrorExt::raise`](crate::ErrorExt) for a fluent way to convert an error into an `Exn` instance.
+    ///
+    /// Note that **sources of `error` are degenerated to their string representation** and all type information is erased.
+    ///
+    /// [source chain of the error]: Error::source
+    #[track_caller]
+    pub fn new(error: E) -> Self {
+        fn walk_sources(error: &dyn Error, location: &'static Location<'static>) -> Vec<Frame> {
+            if let Some(source) = error.source() {
+                let children = vec![Frame {
+                    error: Box::new(SourceError::new(source)),
+                    location,
+                    children: walk_sources(source, location),
+                }];
+                children
+            } else {
+                vec![]
+            }
+        }
+
+        let location = Location::caller();
+        let children = walk_sources(&error, location);
+        let frame = Frame {
+            error: Box::new(error),
+            location,
+            children,
+        };
+
+        Self {
+            frame: Box::new(frame),
+            phantom: PhantomData,
+        }
+    }
+
+    /// Create a new exception with the given error and children.
+    ///
+    /// It's no error if `children` is empty.
+    #[track_caller]
+    pub fn from_iter<T, I>(children: I, err: E) -> Self
+    where
+        T: Error + Send + Sync + 'static,
+        I: IntoIterator,
+        I::Item: Into<Exn<T>>,
+    {
+        let mut new_exn = Exn::new(err);
+        for exn in children {
+            let exn = exn.into();
+            new_exn.frame.children.push(*exn.frame);
+        }
+        new_exn
+    }
+
+    /// Raise a new exception; this will make the current exception a child of the new one.
+    #[track_caller]
+    pub fn raise<T: Error + Send + Sync + 'static>(self, err: T) -> Exn<T> {
+        let mut new_exn = Exn::new(err);
+        new_exn.frame.children.push(*self.frame);
+        new_exn
+    }
+
+    /// Use the current exception the head of a chain, adding `errors` to its children.
+    #[track_caller]
+    pub fn chain_iter<T, I>(mut self, errors: I) -> Exn<E>
+    where
+        T: Error + Send + Sync + 'static,
+        I: IntoIterator,
+        I::Item: Into<Exn<T>>,
+    {
+        for err in errors {
+            let err = err.into();
+            self.frame.children.push(*err.frame);
+        }
+        self
+    }
+
+    /// Drain all sources of this error as untyped [`Exn`].
+    ///
+    /// This is useful if one wants to re-organise errors, and the error layout is well known.
+    pub fn drain_children(&mut self) -> impl Iterator<Item = Exn> + '_ {
+        self.frame.children.drain(..).map(Exn::from)
+    }
+
+    /// Use the current exception the head of a chain, adding all `err` to its children.
+    #[track_caller]
+    pub fn chain<T: Error + Send + Sync + 'static>(mut self, err: impl Into<Exn<T>>) -> Exn<E> {
+        let err = err.into();
+        self.frame.children.push(*err.frame);
+        self
+    }
+
+    /// Erase the type of this instance and turn it into a bare `Exn`.
+    pub fn erased(self) -> Exn {
+        Exn {
+            frame: self.frame,
+            phantom: Default::default(),
+        }
+    }
+
+    /// Return the current exception.
+    pub fn as_error(&self) -> &E {
+        self.frame
+            .error
+            .downcast_ref()
+            .expect("the owned frame always matches the compile-time error type")
+    }
+
+    /// Discard all error context and return the underlying error.
+    ///
+    /// This may be needed to obtain something that once again implements `Error`.
+    pub fn into_box(self) -> Box<E> {
+        match self.frame.error.downcast() {
+            Ok(err) => err,
+            Err(_) => unreachable!("The type in the frame is always the type of this instance"),
+        }
+    }
+
+    /// Turn ourselves into a type that implements [`Error`].
+    pub fn into_error(self) -> crate::Error {
+        self.into()
+    }
+
+    /// Return the underlying exception frame.
+    pub fn as_frame(&self) -> &Frame {
+        &self.frame
+    }
+}
+
+impl<E> Deref for Exn<E>
+where
+    E: Error + Send + Sync + 'static,
+{
+    type Target = E;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_error()
+    }
+}
+
+impl<E: Error + Send + Sync + 'static> fmt::Debug for Exn<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_frame_recursive(f, self.as_frame(), "", ErrorMode::Display, TreeMode::Linearize)
+    }
+}
+
+impl fmt::Debug for Frame {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_frame_recursive(f, self, "", ErrorMode::Display, TreeMode::Linearize)
+    }
+}
+
+#[derive(Copy, Clone)]
+enum ErrorMode {
+    Display,
+    Debug,
+}
+
+#[derive(Copy, Clone)]
+enum TreeMode {
+    Linearize,
+    Verbatim,
+}
+
+fn write_frame_recursive(
+    f: &mut Formatter<'_>,
+    frame: &Frame,
+    prefix: &str,
+    err_mode: ErrorMode,
+    tree_mode: TreeMode,
+) -> fmt::Result {
+    match err_mode {
+        ErrorMode::Display => fmt::Display::fmt(frame.as_error(), f),
+        ErrorMode::Debug => {
+            write!(f, "{:?}", frame.as_error())
+        }
+    }?;
+    if !f.alternate() {
+        write_location(f, frame)?;
+    }
+
+    let children = frame.children();
+    let children_len = children.len();
+
+    for (cidx, child) in children.iter().enumerate() {
+        write!(f, "\n{prefix}|")?;
+        write!(f, "\n{prefix}└─ ")?;
+
+        let child_child_len = child.children().len();
+        let may_linerarize_chain =
+            matches!(tree_mode, TreeMode::Linearize) && children_len == 1 && child_child_len == 1;
+        if may_linerarize_chain {
+            write_frame_recursive(f, child, prefix, err_mode, tree_mode)?;
+        } else if cidx < children_len - 1 {
+            write_frame_recursive(f, child, &format!("{prefix}|   "), err_mode, tree_mode)?;
+        } else {
+            write_frame_recursive(f, child, &format!("{prefix}    "), err_mode, tree_mode)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
+    let location = exn.location();
+    write!(f, ", at {}:{}:{}", location.file(), location.line(), location.column())
+}
+
+impl<E: Error + Send + Sync + 'static> fmt::Display for Exn<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        std::fmt::Display::fmt(&self.frame, f)
+    }
+}
+
+impl fmt::Display for Frame {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if f.alternate() {
+            // Avoid printing alternate versions of the debug info, keep it in one line, also print the tree.
+            write_frame_recursive(f, self, "", ErrorMode::Debug, TreeMode::Verbatim)
+        } else {
+            fmt::Display::fmt(self.as_error(), f)
+        }
+    }
+}
+
+/// A frame in the exception tree.
+pub struct Frame {
+    /// The error that occurred at this frame.
+    error: Box<dyn Error + Send + Sync + 'static>,
+    /// The source code location where this exception frame was created.
+    location: &'static Location<'static>,
+    /// Child exception frames that provide additional context or source errors.
+    children: Vec<Frame>,
+}
+
+impl Frame {
+    /// Return the error as a reference to [`Error`].
+    pub fn as_error(&self) -> &(dyn Error + Send + Sync + 'static) {
+        &*self.error
+    }
+
+    /// Try to downcast this error into the exact type T, or return `None`
+    pub fn downcast<T: Error + 'static>(&self) -> Option<&T> {
+        self.error.downcast_ref()
+    }
+
+    /// Return the source code location where this exception frame was created.
+    pub fn location(&self) -> &'static Location<'static> {
+        self.location
+    }
+
+    /// Return a slice of the children of the exception.
+    pub fn children(&self) -> &[Frame] {
+        &self.children
+    }
+}
+
+impl Frame {
+    /// Return the error as a reference to [`Error`].
+    pub(crate) fn as_error_no_send_sync(&self) -> &(dyn Error + 'static) {
+        &*self.error
+    }
+}
+
+/// Navigation
+impl Frame {
+    /// Find the best possible cause:
+    ///
+    /// * in a linear chain of a single error each, it's the last-most child frame
+    /// * in trees, find the deepest-possible frame that has the most leafs as children
+    ///
+    /// Return `None` if there are no children.
+    pub fn probable_cause(&self) -> Option<&Frame> {
+        fn walk<'a>(frame: &'a Frame, depth: usize) -> (usize, usize, &'a Frame) {
+            if frame.children.is_empty() {
+                return (1, depth, frame);
+            }
+
+            let mut total_leafs = 0;
+            let mut best: Option<(usize, usize, &'a Frame)> = None;
+
+            for child in &frame.children {
+                let (leafs, d, f) = walk(child, depth + 1);
+                total_leafs += leafs;
+
+                match best {
+                    None => best = Some((leafs, d, f)),
+                    Some((bl, bd, _)) => {
+                        if leafs > bl || (leafs == bl && d > bd) {
+                            best = Some((leafs, d, f));
+                        }
+                    }
+                }
+            }
+
+            let self_candidate = (total_leafs, depth, frame);
+            match best {
+                None => self_candidate,
+                Some(best_child) => {
+                    if total_leafs > best_child.0 || (total_leafs == best_child.0 && depth > best_child.1) {
+                        self_candidate
+                    } else {
+                        best_child
+                    }
+                }
+            }
+        }
+
+        // Special case: a simple error just with children would render the same as a chain,
+        //               so pretend the last child is the cause.
+        if self.children().iter().all(|c| c.children().is_empty()) {
+            if let Some(last) = self.children().last() {
+                return Some(last);
+            }
+        }
+
+        let res = walk(self, 0).2;
+        if std::ptr::addr_eq(res, self) {
+            None
+        } else {
+            Some(res)
+        }
+    }
+
+    /// Iterate over all frames in breadth-first order. The first frame is this instance,
+    /// followed by all of its children.
+    pub fn iter(&self) -> impl Iterator<Item = &Frame> + '_ {
+        let mut queue = std::collections::VecDeque::new();
+        queue.push_back(self);
+        BreadthFirstFrames { queue }
+    }
+}
+
+/// Breadth-first iterator over `Frame`s.
+pub struct BreadthFirstFrames<'a> {
+    queue: std::collections::VecDeque<&'a Frame>,
+}
+
+impl<'a> Iterator for BreadthFirstFrames<'a> {
+    type Item = &'a Frame;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let frame = self.queue.pop_front()?;
+        for child in frame.children() {
+            self.queue.push_back(child);
+        }
+        Some(frame)
+    }
+}
+
+impl<E> From<Exn<E>> for Box<Frame>
+where
+    E: Error + Send + Sync + 'static,
+{
+    fn from(err: Exn<E>) -> Self {
+        err.frame
+    }
+}
+
+impl<E> From<Exn<E>> for Frame
+where
+    E: Error + Send + Sync + 'static,
+{
+    fn from(err: Exn<E>) -> Self {
+        *err.frame
+    }
+}
+
+impl From<Frame> for Exn {
+    fn from(frame: Frame) -> Self {
+        Exn {
+            frame: Box::new(frame),
+            phantom: Default::default(),
+        }
+    }
+}
+
+/// A marker to show that type information is not available,
+/// while storing all extractable information about the erased type.
+/// It's the default type for [Exn].
+pub struct Untyped(Box<dyn Error + Send + Sync + 'static>);
+
+impl fmt::Display for Untyped {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        std::fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Debug for Untyped {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        std::fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+impl Error for Untyped {}
+
+/// An error that merely says that something is wrong.
+pub struct Something;
+
+impl fmt::Display for Something {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_str("Something went wrong")
+    }
+}
+
+impl fmt::Debug for Something {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        std::fmt::Display::fmt(&self, f)
+    }
+}
+
+impl Error for Something {}
+
+/// A way to keep all information of errors returned by `source()` chains.
+struct SourceError {
+    display: String,
+    alt_display: String,
+    debug: String,
+    alt_debug: String,
+}
+
+impl fmt::Debug for SourceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let dbg = if f.alternate() { &self.alt_debug } else { &self.debug };
+        f.write_str(dbg)
+    }
+}
+
+impl fmt::Display for SourceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ds = if f.alternate() {
+            &self.alt_display
+        } else {
+            &self.display
+        };
+        f.write_str(ds)
+    }
+}
+
+impl Error for SourceError {}
+
+impl SourceError {
+    fn new(err: &dyn Error) -> Self {
+        SourceError {
+            display: err.to_string(),
+            alt_display: format!("{err:#}"),
+            debug: format!("{err:?}"),
+            alt_debug: format!("{err:#?}"),
+        }
+    }
+}
diff --git a/gix-error/src/exn/macros.rs b/gix-error/src/exn/macros.rs
new file mode 100644
index 00000000000..ca61cd538c9
--- /dev/null
+++ b/gix-error/src/exn/macros.rs
@@ -0,0 +1,102 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Creates an [`Exn`] and returns it as [`Result`].
+///
+/// Shorthand for `return Err(Exn::from(err))`.
+///
+/// # Examples
+///
+/// Create an [`Exn`] from [`Error`]:
+///
+/// [`Exn`]: crate::Exn
+/// [`Error`]: std::error::Error
+///
+/// ```
+/// use std::fs;
+///
+/// use gix_error::bail;
+/// # fn wrapper() -> Result<(), gix_error::Exn<std::io::Error>> {
+/// match fs::read_to_string("/path/to/file") {
+///     Ok(content) => println!("file contents: {content}"),
+///     Err(err) => bail!(err),
+/// }
+/// # Ok(()) }
+/// ```
+#[macro_export]
+macro_rules! bail {
+    ($err:expr) => {{
+        return ::std::result::Result::Err($crate::Exn::from($err));
+    }};
+}
+
+/// Ensures `$cond` is met; otherwise return an error.
+///
+/// Shorthand for `if !$cond { bail!(...); }`.
+///
+/// # Examples
+///
+/// Create an [`Exn`] from an [`Error`]:
+///
+/// [`Exn`]: crate::Exn
+/// [`Error`]: std::error::Error
+///
+/// ```
+/// # fn has_permission(_: &u32, _: &u32) -> bool { true }
+/// # type User = u32;
+/// # let user = 0;
+/// # type Resource = u32;
+/// # let resource = 0;
+/// use std::error::Error;
+/// use std::fmt;
+///
+/// use gix_error::ensure;
+///
+/// #[derive(Debug)]
+/// struct PermissionDenied(User, Resource);
+///
+/// impl fmt::Display for PermissionDenied {
+///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+///         write!(fmt, "permission denied")
+///     }
+/// }
+///
+/// impl Error for PermissionDenied {}
+///
+/// ensure!(
+///     has_permission(&user, &resource),
+///     PermissionDenied(user, resource),
+/// );
+/// # Ok(())
+/// ```
+#[macro_export]
+macro_rules! ensure {
+    ($cond:expr, $err:expr $(,)?) => {{
+        if !bool::from($cond) {
+            $crate::bail!($err)
+        }
+    }};
+}
+
+/// Construct a [`Message`](crate::Message) from a string literal or format string.
+#[macro_export]
+macro_rules! message {
+    ($msg:literal $(,)?) => {
+        // Avoid allocations for string literals.
+        $crate::Message::new($msg)
+    };
+    ($fmt:expr, $($arg:tt)*) => {
+        $crate::Message::new(format!($fmt, $($arg)*))
+    };
+}
diff --git a/gix-error/src/exn/mod.rs b/gix-error/src/exn/mod.rs
new file mode 100644
index 00000000000..a41e5858bb2
--- /dev/null
+++ b/gix-error/src/exn/mod.rs
@@ -0,0 +1,77 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A context-aware concrete Error type built on `std::error::Error`
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![deny(missing_docs)]
+
+mod ext;
+pub use ext::{ErrorExt, OptionExt, ResultExt};
+
+mod impls;
+pub use impls::{Frame, Something, Untyped};
+
+mod macros;
+
+/// An exception type that can hold an [error tree](Exn::from_iter) and the call site.
+///
+/// While an error chain, a list, is automatically created when [raise](Exn::raise)
+/// and friends are invoked, one can also use [`Exn::from_iter`] to create an error
+/// that has multiple causes.
+///
+/// # Warning: `source()` information is stringified and type-erased
+///
+/// All `source()` values are turned into frames, but lose their type information completely.
+/// This is because they are only seen as reference and thus can't be stored.
+///
+/// # `Exn` == `Exn<Untyped>`
+///
+/// `Exn` act's like `Box<dyn std::error::Error + Send + Sync + 'static>`, but with the capability
+/// to store a tree of errors along with their *call sites*.
+///
+/// # Visualisation
+///
+/// Linearized trees during display make a list of 3 children indistinguishable from
+/// 3 errors where each is the child of the other.
+///
+/// ## Debug
+///
+/// * locations: ✔️
+/// * error display: Display
+/// * tree mode: linearized
+///
+/// ## Debug + Alternate
+///
+/// * locations: ❌
+/// * error display: Display
+/// * tree mode: linearized
+///
+/// ## Display
+///
+/// * locations: ❌
+/// * error display: Debug
+/// * tree mode: None
+///
+/// ## Display + Alternate
+///
+/// * locations: ❌
+/// * error display: Debug
+/// * tree mode: verbatim
+pub struct Exn<E: std::error::Error + Send + Sync + 'static = Untyped> {
+    // trade one more indirection for less stack size
+    frame: Box<Frame>,
+    phantom: PhantomData<E>,
+}
+
+use std::marker::PhantomData;
diff --git a/gix-error/src/lib.rs b/gix-error/src/lib.rs
new file mode 100644
index 00000000000..b68b3f898ce
--- /dev/null
+++ b/gix-error/src/lib.rs
@@ -0,0 +1,37 @@
+//! Common error types and utilities for error handling.
+//!
+//! # Usage
+//!
+//! * When there is **no callee error** to track, use *simple* `std::error::Error` implementations directly,
+//!   via `Result<_, Simple>`.
+//! * When there **is callee error to track** *in a `gix-plumbing`*, use `Result<_, Exn<Simple>>`.
+//!      - Remember that `Exn<Simple>` does not implement `std::error::Error` so it's not easy to use outside `gix-` crates.
+//!      - Use the type-erased version in callbacks like [`Exn`] (without type arguments).
+//! * When there **is callee error to track** *in a `gix`*, convert both `std::error::Error` and `Exn<E>` into [`Error`]
+//!
+#![deny(missing_docs, unsafe_code)]
+/// A result type to hide the [Exn] error wrapper.
+mod exn;
+
+pub use exn::{ErrorExt, Exn, Frame, OptionExt, ResultExt, Something, Untyped};
+
+/// An error type that wraps an inner type-erased boxed `std::error::Error` or an `Exn` frame.
+///
+/// In that, it's similar to `anyhow`, but with support for tracking the call site and trees of errors.
+///
+/// # Warning: `source()` information is stringified and type-erased
+///
+/// All `source()` values when created with [`Error::from_error()`] are turned into frames,
+/// but lose their type information completely.
+/// This is because they are only seen as reference and thus can't be stored.
+pub struct Error {
+    inner: error::Inner,
+}
+
+mod error;
+
+mod message;
+pub use message::Message;
+
+mod parse;
+pub use parse::ParseError;
diff --git a/gix-error/src/message.rs b/gix-error/src/message.rs
new file mode 100644
index 00000000000..d232066ca75
--- /dev/null
+++ b/gix-error/src/message.rs
@@ -0,0 +1,25 @@
+use std::borrow::Cow;
+use std::fmt::{Debug, Display, Formatter};
+
+/// An error that is further described in a message.
+#[derive(Debug)]
+pub struct Message(
+    /// The error message.
+    Cow<'static, str>,
+);
+
+/// Lifecycle
+impl Message {
+    /// Create a new instance that displays the given `message`.
+    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
+        Message(message.into())
+    }
+}
+
+impl Display for Message {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.0.as_ref())
+    }
+}
+
+impl std::error::Error for Message {}
diff --git a/gix-error/src/parse.rs b/gix-error/src/parse.rs
new file mode 100644
index 00000000000..2de90493053
--- /dev/null
+++ b/gix-error/src/parse.rs
@@ -0,0 +1,44 @@
+use bstr::BString;
+use std::borrow::Cow;
+use std::fmt::{Debug, Display, Formatter};
+
+/// An error occurred when parsing input
+#[derive(Debug)]
+pub struct ParseError {
+    /// The error message.
+    pub message: Cow<'static, str>,
+    /// The input or portion of the input that failed to parse.
+    pub input: Option<BString>,
+}
+
+/// Lifecycle
+impl ParseError {
+    /// Create a new error with `message` and `input`. Note that `input` isn't printed.
+    pub fn new_with_input(message: impl Into<Cow<'static, str>>, input: impl Into<BString>) -> Self {
+        ParseError {
+            message: message.into(),
+            input: Some(input.into()),
+        }
+    }
+
+    /// Create a new instance that displays the given `message`.
+    pub fn new(message: impl Into<Cow<'static, str>>) -> Self {
+        ParseError {
+            message: message.into(),
+            input: None,
+        }
+    }
+}
+
+impl Display for ParseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match &self.input {
+            None => f.write_str(self.message.as_ref()),
+            Some(input) => {
+                write!(f, "{}: {input}", self.message)
+            }
+        }
+    }
+}
+
+impl std::error::Error for ParseError {}
diff --git a/gix-error/tests/error/error.rs b/gix-error/tests/error/error.rs
new file mode 100644
index 00000000000..b6089d485a8
--- /dev/null
+++ b/gix-error/tests/error/error.rs
@@ -0,0 +1,133 @@
+use crate::{debug_string, new_tree_error, Error as Simple, ErrorWithSource};
+use gix_error::{Error, ErrorExt};
+use std::error::Error as _;
+
+#[test]
+fn from_exn_error() {
+    let err = Error::from(Simple("one").raise());
+    assert_eq!(err.to_string(), "one");
+    insta::assert_snapshot!(debug_string(&err), @"one, at gix-error/tests/error/error.rs:7:41");
+    insta::assert_debug_snapshot!(err, @"one");
+    assert_eq!(err.source().map(debug_string), None);
+}
+
+#[test]
+fn from_exn_error_tree() {
+    let err = Error::from(new_tree_error().raise(Simple("topmost")));
+    assert_eq!(err.to_string(), "topmost");
+    insta::assert_snapshot!(debug_string(&err), @r"
+    topmost, at gix-error/tests/error/error.rs:16:44
+    |
+    └─ E6, at gix-error/tests/error/main.rs:25:9
+        |
+        └─ E5, at gix-error/tests/error/main.rs:17:18
+        |   |
+        |   └─ E3, at gix-error/tests/error/main.rs:9:21
+        |   |   |
+        |   |   └─ E1, at gix-error/tests/error/main.rs:8:30
+        |   |
+        |   └─ E10, at gix-error/tests/error/main.rs:12:22
+        |   |   |
+        |   |   └─ E9, at gix-error/tests/error/main.rs:11:30
+        |   |
+        |   └─ E12, at gix-error/tests/error/main.rs:15:23
+        |       |
+        |       └─ E11, at gix-error/tests/error/main.rs:14:32
+        |
+        └─ E4, at gix-error/tests/error/main.rs:20:21
+        |   |
+        |   └─ E2, at gix-error/tests/error/main.rs:19:30
+        |
+        └─ E8, at gix-error/tests/error/main.rs:23:21
+            |
+            └─ E7, at gix-error/tests/error/main.rs:22:30
+    ");
+    insta::assert_debug_snapshot!(err, @r"
+    topmost
+    |
+    └─ E6
+        |
+        └─ E5
+        |   |
+        |   └─ E3
+        |   |   |
+        |   |   └─ E1
+        |   |
+        |   └─ E10
+        |   |   |
+        |   |   └─ E9
+        |   |
+        |   └─ E12
+        |       |
+        |       └─ E11
+        |
+        └─ E4
+        |   |
+        |   └─ E2
+        |
+        └─ E8
+            |
+            └─ E7
+    ");
+    insta::assert_debug_snapshot!(err.iter_frames().map(ToString::to_string).collect::<Vec<_>>(), @r#"
+    [
+        "topmost",
+        "E6",
+        "E5",
+        "E4",
+        "E8",
+        "E3",
+        "E10",
+        "E12",
+        "E2",
+        "E7",
+        "E1",
+        "E9",
+        "E11",
+    ]
+    "#);
+    assert_eq!(
+        err.source().map(debug_string).as_deref(),
+        Some(r#"Error("E6")"#),
+        "The source is the first child"
+    );
+    assert_eq!(
+        err.probable_cause().to_string(),
+        "E6",
+        "we get the top-most error that has most causes"
+    );
+}
+
+#[test]
+fn from_any_error() {
+    let err = Error::from_error(Simple("one"));
+    assert_eq!(err.to_string(), "one");
+    assert_eq!(debug_string(&err), r#"Error("one")"#);
+    insta::assert_debug_snapshot!(err, @r#"
+    Error(
+        "one",
+    )
+    "#);
+    assert_eq!(err.source().map(debug_string), None);
+    assert_eq!(err.probable_cause().to_string(), "one");
+}
+
+#[test]
+fn from_any_error_with_source() {
+    let err = Error::from_error(ErrorWithSource("main", Simple("one")));
+    assert_eq!(err.to_string(), "main", "display is the error itself");
+    assert_eq!(debug_string(&err), r#"ErrorWithSource("main", Error("one"))"#);
+    insta::assert_debug_snapshot!(err, @r#"
+    ErrorWithSource(
+        "main",
+        Error(
+            "one",
+        ),
+    )
+    "#);
+    assert_eq!(
+        err.source().map(debug_string).as_deref(),
+        Some(r#"Error("one")"#),
+        "The source is provided by the wrapped error"
+    );
+}
diff --git a/gix-error/tests/error/exn.rs b/gix-error/tests/error/exn.rs
new file mode 100644
index 00000000000..e3148deb185
--- /dev/null
+++ b/gix-error/tests/error/exn.rs
@@ -0,0 +1,486 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::{debug_string, new_tree_error, Error, ErrorWithSource};
+use gix_error::Exn;
+use gix_error::OptionExt;
+use gix_error::ResultExt;
+use gix_error::{message, ErrorExt};
+
+#[test]
+fn raise_chain() {
+    let e1 = Error("E1").raise();
+    let e2 = e1.raise(Error("E2"));
+    let e3 = e2.raise(Error("E3"));
+    let e4 = e3.raise(Error("E4"));
+    let e5 = e4.raise(Error("E5"));
+    insta::assert_debug_snapshot!(e5, @r"
+    E5
+    |
+    └─ E4
+    |
+    └─ E3
+    |
+    └─ E2
+    |
+    └─ E1
+    ");
+    insta::assert_snapshot!(debug_string(&e5), @r"
+    E5, at gix-error/tests/error/exn.rs:27:17
+    |
+    └─ E4, at gix-error/tests/error/exn.rs:26:17
+    |
+    └─ E3, at gix-error/tests/error/exn.rs:25:17
+    |
+    └─ E2, at gix-error/tests/error/exn.rs:24:17
+    |
+    └─ E1, at gix-error/tests/error/exn.rs:23:26
+    ");
+
+    let e = e5.erased();
+    insta::assert_debug_snapshot!(e, @r"
+    E5
+    |
+    └─ E4
+    |
+    └─ E3
+    |
+    └─ E2
+    |
+    └─ E1
+    ");
+    insta::assert_snapshot!(format!("{e:#}"), @r#"
+    Error("E5")
+    |
+    └─ Error("E4")
+        |
+        └─ Error("E3")
+            |
+            └─ Error("E2")
+                |
+                └─ Error("E1")
+    "#);
+    insta::assert_snapshot!(format!("{e:}"), @"E5");
+
+    insta::assert_snapshot!(debug_string(&e), @r"
+    E5, at gix-error/tests/error/exn.rs:27:17
+    |
+    └─ E4, at gix-error/tests/error/exn.rs:26:17
+    |
+    └─ E3, at gix-error/tests/error/exn.rs:25:17
+    |
+    └─ E2, at gix-error/tests/error/exn.rs:24:17
+    |
+    └─ E1, at gix-error/tests/error/exn.rs:23:26
+    ");
+
+    // Double-erase
+    let e = e.erased();
+    insta::assert_debug_snapshot!(e, @r"
+    E5
+    |
+    └─ E4
+    |
+    └─ E3
+    |
+    └─ E2
+    |
+    └─ E1
+    ");
+
+    insta::assert_snapshot!(format!("{e:#}"), @r#"
+    Error("E5")
+    |
+    └─ Error("E4")
+        |
+        └─ Error("E3")
+            |
+            └─ Error("E2")
+                |
+                └─ Error("E1")
+    "#);
+    assert_eq!(
+        e.into_error().probable_cause().to_string(),
+        "E1",
+        "linear chains are just followed"
+    );
+}
+
+#[test]
+fn raise_iter() {
+    let e = Error("Top").raise_iter(
+        (1..5).map(|idx| message!("E{}", idx).raise_iter((0..idx).map(|sidx| message!("E{}-{}", idx, sidx)))),
+    );
+    insta::assert_debug_snapshot!(e, @r"
+    Top
+    |
+    └─ E1
+    |   |
+    |   └─ E1-0
+    |
+    └─ E2
+    |   |
+    |   └─ E2-0
+    |   |
+    |   └─ E2-1
+    |
+    └─ E3
+    |   |
+    |   └─ E3-0
+    |   |
+    |   └─ E3-1
+    |   |
+    |   └─ E3-2
+    |
+    └─ E4
+        |
+        └─ E4-0
+        |
+        └─ E4-1
+        |
+        └─ E4-2
+        |
+        └─ E4-3
+    ");
+    insta::assert_snapshot!(debug_string(&e), @r"
+    Top, at gix-error/tests/error/exn.rs:122:26
+    |
+    └─ E1, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E1-0, at gix-error/tests/error/exn.rs:123:47
+    |
+    └─ E2, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E2-0, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E2-1, at gix-error/tests/error/exn.rs:123:47
+    |
+    └─ E3, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E3-0, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E3-1, at gix-error/tests/error/exn.rs:123:47
+    |   |
+    |   └─ E3-2, at gix-error/tests/error/exn.rs:123:47
+    |
+    └─ E4, at gix-error/tests/error/exn.rs:123:47
+        |
+        └─ E4-0, at gix-error/tests/error/exn.rs:123:47
+        |
+        └─ E4-1, at gix-error/tests/error/exn.rs:123:47
+        |
+        └─ E4-2, at gix-error/tests/error/exn.rs:123:47
+        |
+        └─ E4-3, at gix-error/tests/error/exn.rs:123:47
+    ");
+
+    let e = e.chain_iter((1..3).map(|idx| message!("SE{}", idx)));
+    insta::assert_debug_snapshot!(e, @r"
+    Top
+    |
+    └─ E1
+    |   |
+    |   └─ E1-0
+    |
+    └─ E2
+    |   |
+    |   └─ E2-0
+    |   |
+    |   └─ E2-1
+    |
+    └─ E3
+    |   |
+    |   └─ E3-0
+    |   |
+    |   └─ E3-1
+    |   |
+    |   └─ E3-2
+    |
+    └─ E4
+    |   |
+    |   └─ E4-0
+    |   |
+    |   └─ E4-1
+    |   |
+    |   └─ E4-2
+    |   |
+    |   └─ E4-3
+    |
+    └─ SE1
+    |
+    └─ SE2
+    ");
+
+    insta::assert_snapshot!(format!("{:#}", e), @r#"
+    Error("Top")
+    |
+    └─ Message("E1")
+    |   |
+    |   └─ Message("E1-0")
+    |
+    └─ Message("E2")
+    |   |
+    |   └─ Message("E2-0")
+    |   |
+    |   └─ Message("E2-1")
+    |
+    └─ Message("E3")
+    |   |
+    |   └─ Message("E3-0")
+    |   |
+    |   └─ Message("E3-1")
+    |   |
+    |   └─ Message("E3-2")
+    |
+    └─ Message("E4")
+    |   |
+    |   └─ Message("E4-0")
+    |   |
+    |   └─ Message("E4-1")
+    |   |
+    |   └─ Message("E4-2")
+    |   |
+    |   └─ Message("E4-3")
+    |
+    └─ Message("SE1")
+    |
+    └─ Message("SE2")
+    "#);
+    let _this_should_compile = Error("Top-untyped").raise_iter((1..5).map(|idx| message!("E{}", idx).erased()));
+
+    assert_eq!(
+        e.into_error().probable_cause().to_string(),
+        "Top",
+        "sometimes the cause is too ambiguous"
+    );
+}
+
+#[test]
+fn inverse_error_call_chain() {
+    let e1 = Error("E1").raise();
+    let e2 = e1.chain(Error("E2"));
+    let e3 = e2.chain(Error("E3"));
+    let e4 = e3.chain(Error("E4"));
+    let e5 = e4.chain(Error("E5"));
+    insta::assert_debug_snapshot!(e5, @r"
+    E1
+    |
+    └─ E2
+    |
+    └─ E3
+    |
+    └─ E4
+    |
+    └─ E5
+    ");
+    insta::assert_snapshot!(debug_string(&e5), @r"
+    E1, at gix-error/tests/error/exn.rs:271:26
+    |
+    └─ E2, at gix-error/tests/error/exn.rs:272:17
+    |
+    └─ E3, at gix-error/tests/error/exn.rs:273:17
+    |
+    └─ E4, at gix-error/tests/error/exn.rs:274:17
+    |
+    └─ E5, at gix-error/tests/error/exn.rs:275:17
+    ");
+
+    insta::assert_snapshot!(format!("{e5:#}"), @r#"
+    Error("E1")
+    |
+    └─ Error("E2")
+    |
+    └─ Error("E3")
+    |
+    └─ Error("E4")
+    |
+    └─ Error("E5")
+    "#);
+
+    assert_eq!(e5.into_error().probable_cause().to_string(), "E5");
+}
+
+#[test]
+fn error_tree() {
+    let mut err = new_tree_error();
+    insta::assert_debug_snapshot!(err, @r"
+    E6
+    |
+    └─ E5
+    |   |
+    |   └─ E3
+    |   |   |
+    |   |   └─ E1
+    |   |
+    |   └─ E10
+    |   |   |
+    |   |   └─ E9
+    |   |
+    |   └─ E12
+    |       |
+    |       └─ E11
+    |
+    └─ E4
+    |   |
+    |   └─ E2
+    |
+    └─ E8
+        |
+        └─ E7
+    ");
+    insta::assert_snapshot!(debug_string(&err), @r"
+    E6, at gix-error/tests/error/main.rs:25:9
+    |
+    └─ E5, at gix-error/tests/error/main.rs:17:18
+    |   |
+    |   └─ E3, at gix-error/tests/error/main.rs:9:21
+    |   |   |
+    |   |   └─ E1, at gix-error/tests/error/main.rs:8:30
+    |   |
+    |   └─ E10, at gix-error/tests/error/main.rs:12:22
+    |   |   |
+    |   |   └─ E9, at gix-error/tests/error/main.rs:11:30
+    |   |
+    |   └─ E12, at gix-error/tests/error/main.rs:15:23
+    |       |
+    |       └─ E11, at gix-error/tests/error/main.rs:14:32
+    |
+    └─ E4, at gix-error/tests/error/main.rs:20:21
+    |   |
+    |   └─ E2, at gix-error/tests/error/main.rs:19:30
+    |
+    └─ E8, at gix-error/tests/error/main.rs:23:21
+        |
+        └─ E7, at gix-error/tests/error/main.rs:22:30
+    ");
+    insta::assert_debug_snapshot!(err.as_frame().iter().map(ToString::to_string).collect::<Vec<_>>(), @r#"
+    [
+        "E6",
+        "E5",
+        "E4",
+        "E8",
+        "E3",
+        "E10",
+        "E12",
+        "E2",
+        "E7",
+        "E1",
+        "E9",
+        "E11",
+    ]
+    "#);
+
+    let new_e = Error("E-New").raise_iter(err.drain_children());
+    insta::assert_debug_snapshot!(new_e, @r"
+    E-New
+    |
+    └─ E5
+    |   |
+    |   └─ E3
+    |   |   |
+    |   |   └─ E1
+    |   |
+    |   └─ E10
+    |   |   |
+    |   |   └─ E9
+    |   |
+    |   └─ E12
+    |       |
+    |       └─ E11
+    |
+    └─ E4
+    |   |
+    |   └─ E2
+    |
+    └─ E8
+        |
+        └─ E7
+    ");
+    insta::assert_snapshot!(err, @"E6");
+}
+
+#[test]
+fn result_ext() {
+    let result: Result<(), Error> = Err(Error("An error"));
+    let result = result.or_raise(|| Error("Another error"));
+    insta::assert_snapshot!(debug_string(result.unwrap_err()), @r"
+    Another error, at gix-error/tests/error/exn.rs:416:25
+    |
+    └─ An error, at gix-error/tests/error/exn.rs:416:25
+    ");
+}
+
+#[test]
+fn option_ext() {
+    let result: Option<()> = None;
+    let result = result.ok_or_raise(|| Error("An error"));
+    insta::assert_snapshot!(debug_string(result.unwrap_err()), @"An error, at gix-error/tests/error/exn.rs:427:25");
+}
+
+#[test]
+fn from_error() {
+    fn foo() -> Result<(), Exn<Error>> {
+        Err(Error("An error"))?;
+        Ok(())
+    }
+
+    let result = foo();
+    insta::assert_snapshot!(debug_string(result.unwrap_err()),@"An error, at gix-error/tests/error/exn.rs:434:9");
+}
+
+#[test]
+fn new_with_source() {
+    let e = Exn::new(ErrorWithSource("top", Error("source")));
+    insta::assert_debug_snapshot!(e,@r"
+    top
+    |
+    └─ source
+    ");
+}
+
+#[test]
+fn bail() {
+    fn foo() -> Result<(), Exn<Error>> {
+        gix_error::bail!(Error("An error"));
+    }
+
+    let result = foo();
+    insta::assert_snapshot!(debug_string(result.unwrap_err()), @"An error, at gix-error/tests/error/exn.rs:455:9");
+}
+
+#[test]
+fn ensure_ok() {
+    fn foo() -> Result<(), Exn<Error>> {
+        gix_error::ensure!(true, Error("An error"));
+        Ok(())
+    }
+
+    foo().unwrap();
+}
+
+#[test]
+fn ensure_fail() {
+    fn foo() -> Result<(), Exn<Error>> {
+        gix_error::ensure!(false, Error("An error"));
+        Ok(())
+    }
+
+    let result = foo();
+    insta::assert_snapshot!(debug_string(result.unwrap_err()), @"An error, at gix-error/tests/error/exn.rs:475:9");
+}
+
+#[test]
+fn result_ok() -> Result<(), Exn<Error>> {
+    Ok(())
+}
diff --git a/gix-error/tests/error/main.rs b/gix-error/tests/error/main.rs
new file mode 100644
index 00000000000..c98cddbf189
--- /dev/null
+++ b/gix-error/tests/error/main.rs
@@ -0,0 +1,63 @@
+mod error;
+mod exn;
+
+mod utils {
+    use gix_error::{ErrorExt, Exn};
+
+    pub fn new_tree_error() -> Exn<Error> {
+        let e1 = Error("E1").raise();
+        let e3 = e1.raise(Error("E3"));
+
+        let e9 = Error("E9").raise();
+        let e10 = e9.raise(Error("E10"));
+
+        let e11 = Error("E11").raise();
+        let e12 = e11.raise(Error("E12"));
+
+        let e5 = Exn::from_iter([e3, e10, e12], Error("E5"));
+
+        let e2 = Error("E2").raise();
+        let e4 = e2.raise(Error("E4"));
+
+        let e7 = Error("E7").raise();
+        let e8 = e7.raise(Error("E8"));
+
+        Exn::from_iter([e5, e4, e8], Error("E6"))
+    }
+
+    #[derive(Debug)]
+    pub struct Error(pub &'static str);
+
+    impl std::fmt::Display for Error {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{}", self.0)
+        }
+    }
+
+    impl std::error::Error for Error {}
+
+    pub fn debug_string(input: impl std::fmt::Debug) -> String {
+        if cfg!(windows) {
+            let out = format!("{input:?}");
+            out.replace('\\', "/")
+        } else {
+            format!("{input:?}")
+        }
+    }
+
+    #[derive(Debug)]
+    pub struct ErrorWithSource(pub &'static str, pub Error);
+
+    impl std::fmt::Display for ErrorWithSource {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{}", self.0)
+        }
+    }
+
+    impl std::error::Error for ErrorWithSource {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            Some(&self.1)
+        }
+    }
+}
+pub use utils::*;
diff --git a/gix-refspec/Cargo.toml b/gix-refspec/Cargo.toml
index 1481bd1f518..d6905409345 100644
--- a/gix-refspec/Cargo.toml
+++ b/gix-refspec/Cargo.toml
@@ -15,6 +15,7 @@ rust-version = "1.82"
 doctest = false
 
 [dependencies]
+gix-error = { version = "0.0.0", path = "../gix-error" }
 gix-revision = { version = "^0.39.0", path = "../gix-revision", default-features = false }
 gix-validate = { version = "^0.10.1", path = "../gix-validate" }
 gix-hash = { version = "^0.21.2", path = "../gix-hash" }
diff --git a/gix-refspec/src/parse.rs b/gix-refspec/src/parse.rs
index 6844d2f7ecb..df5022b3725 100644
--- a/gix-refspec/src/parse.rs
+++ b/gix-refspec/src/parse.rs
@@ -25,7 +25,7 @@ pub enum Error {
     #[error(transparent)]
     ReferenceName(#[from] gix_validate::reference::name::Error),
     #[error(transparent)]
-    RevSpec(#[from] gix_revision::spec::parse::Error),
+    RevSpec(#[from] Box<gix_revision::spec::parse::Error>),
 }
 
 /// Define how the parsed refspec should be used.
@@ -38,13 +38,13 @@ pub enum Operation {
 }
 
 pub(crate) mod function {
-    use bstr::{BStr, ByteSlice};
-
     use crate::{
         parse::{Error, Operation},
         types::Mode,
         RefSpecRef,
     };
+    use bstr::{BStr, ByteSlice};
+    use gix_error::Exn;
 
     /// Parse `spec` for use in `operation` and return it if it is valid.
     pub fn parse(mut spec: &BStr, operation: Operation) -> Result<RefSpecRef<'_>, Error> {
@@ -181,7 +181,7 @@ pub(crate) mod function {
                         .map_err(Error::from)
                         .or_else(|err| {
                             if allow_revspecs {
-                                gix_revision::spec::parse(spec, &mut super::revparse::Noop)?;
+                                gix_revision::spec::parse(spec, &mut super::revparse::Noop).map_err(Exn::into_box)?;
                                 Ok(spec)
                             } else {
                                 Err(err)
@@ -197,6 +197,7 @@ pub(crate) mod function {
 
 mod revparse {
     use bstr::BStr;
+    use gix_error::Exn;
     use gix_revision::spec::parse::delegate::{
         Kind, Navigate, PeelTo, PrefixHint, ReflogLookup, Revision, SiblingBranch, Traversal,
     };
@@ -204,52 +205,54 @@ mod revparse {
     pub(crate) struct Noop;
 
     impl Revision for Noop {
-        fn find_ref(&mut self, _name: &BStr) -> Option<()> {
-            Some(())
+        fn find_ref(&mut self, _name: &BStr) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn disambiguate_prefix(&mut self, _prefix: gix_hash::Prefix, _hint: Option<PrefixHint<'_>>) -> Option<()> {
-            Some(())
+        fn disambiguate_prefix(&mut self, _prefix: gix_hash::Prefix, _hint: Option<PrefixHint<'_>>) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn reflog(&mut self, _query: ReflogLookup) -> Option<()> {
-            Some(())
+        fn reflog(&mut self, _query: ReflogLookup) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn nth_checked_out_branch(&mut self, _branch_no: usize) -> Option<()> {
-            Some(())
+        fn nth_checked_out_branch(&mut self, _branch_no: usize) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn sibling_branch(&mut self, _kind: SiblingBranch) -> Option<()> {
-            Some(())
+        fn sibling_branch(&mut self, _kind: SiblingBranch) -> Result<(), Exn> {
+            Ok(())
         }
     }
 
     impl Navigate for Noop {
-        fn traverse(&mut self, _kind: Traversal) -> Option<()> {
-            Some(())
+        fn traverse(&mut self, _kind: Traversal) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn peel_until(&mut self, _kind: PeelTo<'_>) -> Option<()> {
-            Some(())
+        fn peel_until(&mut self, _kind: PeelTo<'_>) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn find(&mut self, _regex: &BStr, _negated: bool) -> Option<()> {
-            Some(())
+        fn find(&mut self, _regex: &BStr, _negated: bool) -> Result<(), Exn> {
+            Ok(())
         }
 
-        fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> Option<()> {
-            Some(())
+        fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> Result<(), Exn> {
+            Ok(())
         }
     }
 
     impl Kind for Noop {
-        fn kind(&mut self, _kind: gix_revision::spec::Kind) -> Option<()> {
-            Some(())
+        fn kind(&mut self, _kind: gix_revision::spec::Kind) -> Result<(), Exn> {
+            Ok(())
         }
     }
 
     impl gix_revision::spec::parse::Delegate for Noop {
-        fn done(&mut self) {}
+        fn done(&mut self) -> Result<(), Exn> {
+            Ok(())
+        }
     }
 }
diff --git a/gix-revision/Cargo.toml b/gix-revision/Cargo.toml
index 9836b2295c0..55ae624a912 100644
--- a/gix-revision/Cargo.toml
+++ b/gix-revision/Cargo.toml
@@ -27,6 +27,7 @@ merge_base = ["dep:gix-trace", "dep:bitflags"]
 serde = ["dep:serde", "gix-hash/serde", "gix-object/serde"]
 
 [dependencies]
+gix-error = { version = "0.0.0", path = "../gix-error" }
 gix-hash = { version = "^0.21.2", path = "../gix-hash" }
 gix-object = { version = "^0.54.1", path = "../gix-object" }
 gix-date = { version = "^0.12.1", path = "../gix-date" }
@@ -37,11 +38,11 @@ gix-trace = { version = "^0.1.17", path = "../gix-trace", optional = true }
 
 bstr = { version = "1.12.0", default-features = false, features = ["std"] }
 bitflags = { version = "2", optional = true }
-thiserror = "2.0.17"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
+insta = "1.46.0"
 gix-odb = { path = "../gix-odb" }
 gix-testtools = { path = "../tests/tools" }
 permutohedron = "0.2.4"
diff --git a/gix-revision/fuzz/Cargo.toml b/gix-revision/fuzz/Cargo.toml
index e6ef0c1461d..2438ba2261e 100644
--- a/gix-revision/fuzz/Cargo.toml
+++ b/gix-revision/fuzz/Cargo.toml
@@ -11,6 +11,7 @@ cargo-fuzz = true
 [dependencies]
 libfuzzer-sys = "0.4"
 gix-hash = { path = "../../gix-hash" }
+gix-error = { path = "../../gix-error" }
 bstr = { version = "1.5.0", default-features = false }
 
 [dependencies.gix-revision]
diff --git a/gix-revision/fuzz/fuzz_targets/parse.rs b/gix-revision/fuzz/fuzz_targets/parse.rs
index 888bab059fb..57472ab587c 100644
--- a/gix-revision/fuzz/fuzz_targets/parse.rs
+++ b/gix-revision/fuzz/fuzz_targets/parse.rs
@@ -3,6 +3,7 @@ use gix_revision::spec::parse::{delegate, Delegate};
 use libfuzzer_sys::fuzz_target;
 
 use bstr::BStr;
+use gix_error::Exn;
 
 fuzz_target!(|data: &[u8]| {
     drop(gix_revision::spec::parse(data.into(), &mut Noop));
@@ -11,55 +12,57 @@ fuzz_target!(|data: &[u8]| {
 struct Noop;
 
 impl Delegate for Noop {
-    fn done(&mut self) {}
+    fn done(&mut self) -> Result<(), Exn> {
+        Ok(())
+    }
 }
 
 impl delegate::Kind for Noop {
-    fn kind(&mut self, _kind: gix_revision::spec::Kind) -> Option<()> {
-        Some(())
+    fn kind(&mut self, _kind: gix_revision::spec::Kind) -> Result<(), Exn> {
+        Ok(())
     }
 }
 
 impl delegate::Navigate for Noop {
-    fn traverse(&mut self, _kind: delegate::Traversal) -> Option<()> {
-        Some(())
+    fn traverse(&mut self, _kind: delegate::Traversal) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn peel_until(&mut self, _kind: delegate::PeelTo<'_>) -> Option<()> {
-        Some(())
+    fn peel_until(&mut self, _kind: delegate::PeelTo<'_>) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn find(&mut self, _regex: &BStr, _negated: bool) -> Option<()> {
-        Some(())
+    fn find(&mut self, _regex: &BStr, _negated: bool) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> Option<()> {
-        Some(())
+    fn index_lookup(&mut self, _path: &BStr, _stage: u8) -> Result<(), Exn> {
+        Ok(())
     }
 }
 
 impl delegate::Revision for Noop {
-    fn find_ref(&mut self, _name: &BStr) -> Option<()> {
-        Some(())
+    fn find_ref(&mut self, _name: &BStr) -> Result<(), Exn> {
+        Ok(())
     }
 
     fn disambiguate_prefix(
         &mut self,
         _prefix: gix_hash::Prefix,
         _hint: Option<delegate::PrefixHint<'_>>,
-    ) -> Option<()> {
-        Some(())
+    ) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn reflog(&mut self, _query: delegate::ReflogLookup) -> Option<()> {
-        Some(())
+    fn reflog(&mut self, _query: delegate::ReflogLookup) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn nth_checked_out_branch(&mut self, _branch_no: usize) -> Option<()> {
-        Some(())
+    fn nth_checked_out_branch(&mut self, _branch_no: usize) -> Result<(), Exn> {
+        Ok(())
     }
 
-    fn sibling_branch(&mut self, _kind: delegate::SiblingBranch) -> Option<()> {
-        Some(())
+    fn sibling_branch(&mut self, _kind: delegate::SiblingBranch) -> Result<(), Exn> {
+        Ok(())
     }
 }
diff --git a/gix-revision/src/describe.rs b/gix-revision/src/describe.rs
index cb92dec099f..ded95b7d254 100644
--- a/gix-revision/src/describe.rs
+++ b/gix-revision/src/describe.rs
@@ -127,24 +127,14 @@ impl Default for Options<'_> {
     }
 }
 
-/// The error returned by the [`describe()`][function::describe()] function.
-#[derive(Debug, thiserror::Error)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("The parents of commit {} could not be added to graph during traversal", oid.to_hex())]
-    InsertParentsToGraph {
-        #[source]
-        err: crate::graph::insert_parents::Error,
-        oid: gix_hash::ObjectId,
-    },
-    #[error("A commit could not be decoded during traversal")]
-    Decode(#[from] gix_object::decode::Error),
-}
+/// The error returned by the [`describe()`](function::describe()) function.
+pub type Error = gix_error::Message;
 
 pub(crate) mod function {
     use std::{borrow::Cow, cmp::Ordering};
 
     use bstr::BStr;
+    use gix_error::{message, Exn, ResultExt};
     use gix_hash::oid;
 
     use super::{Error, Outcome};
@@ -154,7 +144,7 @@ pub(crate) mod function {
     };
 
     /// Given a `commit` id, traverse the commit `graph` and collect candidate names from the `name_by_oid` mapping to produce
-    /// an `Outcome`, which converted [`into_format()`][Outcome::into_format()] will produce a typical `git describe` string.
+    /// an `Outcome`, which converted [`into_format()`](Outcome::into_format()) will produce a typical `git describe` string.
     ///
     /// Note that the `name_by_oid` map is returned in the [`Outcome`], which can be forcefully returned even if there was no matching
     /// candidate by setting `fallback_to_oid` to true.
@@ -167,7 +157,7 @@ pub(crate) mod function {
             fallback_to_oid,
             first_parent,
         }: Options<'name>,
-    ) -> Result<Option<Outcome<'name>>, Error> {
+    ) -> Result<Option<Outcome<'name>>, Exn<Error>> {
         let _span = gix_trace::coarse!(
             "gix_revision::describe()",
             commit = %commit,
@@ -309,7 +299,7 @@ pub(crate) mod function {
         commit: gix_hash::ObjectId,
         commit_flags: Flags,
         first_parent: bool,
-    ) -> Result<(), Error> {
+    ) -> Result<(), Exn<Error>> {
         graph
             .insert_parents(
                 &commit,
@@ -320,7 +310,7 @@ pub(crate) mod function {
                 &mut |_parent_id, flags| *flags |= commit_flags,
                 first_parent,
             )
-            .map_err(|err| Error::InsertParentsToGraph { err, oid: commit })?;
+            .or_raise(|| message!("could not insert parents of commit {} into graph", commit.to_hex()))?;
         Ok(())
     }
 
@@ -329,7 +319,7 @@ pub(crate) mod function {
         graph: &mut Graph<'_, '_, Flags>,
         best_candidate: &mut Candidate<'_>,
         first_parent: bool,
-    ) -> Result<u32, Error> {
+    ) -> Result<u32, Exn<Error>> {
         let mut commits_seen = 0;
         while let Some(commit) = queue.pop_value() {
             commits_seen += 1;
diff --git a/gix-revision/src/merge_base/function.rs b/gix-revision/src/merge_base/function.rs
index b84805b869c..224ea815c1a 100644
--- a/gix-revision/src/merge_base/function.rs
+++ b/gix-revision/src/merge_base/function.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use gix_hash::ObjectId;
 use gix_revwalk::graph;
 
-use super::Error;
+use super::{Error, Simple};
 use crate::{merge_base::Flags, Graph, PriorityQueue};
 
 /// Given a commit at `first` id, traverse the commit `graph` and return all possible merge-base between it and `others`,
@@ -63,13 +63,15 @@ fn remove_redundant(
         let commit = graph.get_mut(id).expect("previously added");
         commit.data |= Flags::RESULT;
         for parent_id in commit.parents.clone() {
-            graph.get_or_insert_full_commit(parent_id, |parent| {
-                // prevent double-addition
-                if !parent.data.contains(Flags::STALE) {
-                    parent.data |= Flags::STALE;
-                    walk_start.push((parent_id, GenThenTime::from(&*parent)));
-                }
-            })?;
+            graph
+                .get_or_insert_full_commit(parent_id, |parent| {
+                    // prevent double-addition
+                    if !parent.data.contains(Flags::STALE) {
+                        parent.data |= Flags::STALE;
+                        walk_start.push((parent_id, GenThenTime::from(&*parent)));
+                    }
+                })
+                .map_err(|_| Simple("could not insert parent commit into graph"))?;
         }
     }
     walk_start.sort_by(|a, b| a.0.cmp(&b.0));
@@ -121,7 +123,8 @@ fn remove_redundant(
                             parent.data |= Flags::STALE;
                             stack.push((*parent_id, GenThenTime::from(&*parent)));
                         }
-                    })?
+                    })
+                    .map_err(|_| Simple("could not insert parent commit into graph"))?
                     .is_some()
                 {
                     break;
@@ -151,16 +154,20 @@ fn paint_down_to_common(
     graph: &mut Graph<'_, '_, graph::Commit<Flags>>,
 ) -> Result<Vec<(ObjectId, GenThenTime)>, Error> {
     let mut queue = PriorityQueue::<GenThenTime, ObjectId>::new();
-    graph.get_or_insert_full_commit(first, |commit| {
-        commit.data |= Flags::COMMIT1;
-        queue.insert(GenThenTime::from(&*commit), first);
-    })?;
+    graph
+        .get_or_insert_full_commit(first, |commit| {
+            commit.data |= Flags::COMMIT1;
+            queue.insert(GenThenTime::from(&*commit), first);
+        })
+        .map_err(|_| Simple("could not insert commit into graph"))?;
 
     for other in others {
-        graph.get_or_insert_full_commit(*other, |commit| {
-            commit.data |= Flags::COMMIT2;
-            queue.insert(GenThenTime::from(&*commit), *other);
-        })?;
+        graph
+            .get_or_insert_full_commit(*other, |commit| {
+                commit.data |= Flags::COMMIT2;
+                queue.insert(GenThenTime::from(&*commit), *other);
+            })
+            .map_err(|_| Simple("could not insert commit into graph"))?;
     }
 
     let mut out = Vec::new();
@@ -180,12 +187,14 @@ fn paint_down_to_common(
         }
 
         for parent_id in commit.parents.clone() {
-            graph.get_or_insert_full_commit(parent_id, |parent| {
-                if (parent.data & flags_without_result) != flags_without_result {
-                    parent.data |= flags_without_result;
-                    queue.insert(GenThenTime::from(&*parent), parent_id);
-                }
-            })?;
+            graph
+                .get_or_insert_full_commit(parent_id, |parent| {
+                    if (parent.data & flags_without_result) != flags_without_result {
+                        parent.data |= flags_without_result;
+                        queue.insert(GenThenTime::from(&*parent), parent_id);
+                    }
+                })
+                .map_err(|_| Simple("could not insert parent commit into graph"))?;
         }
     }
 
diff --git a/gix-revision/src/merge_base/mod.rs b/gix-revision/src/merge_base/mod.rs
index b07e39691d5..aeb899ed82c 100644
--- a/gix-revision/src/merge_base/mod.rs
+++ b/gix-revision/src/merge_base/mod.rs
@@ -15,13 +15,20 @@ bitflags::bitflags! {
 }
 
 /// The error returned by the [`merge_base()`][function::merge_base()] function.
-#[derive(Debug, thiserror::Error)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("A commit could not be inserted into the graph")]
-    InsertCommit(#[from] gix_revwalk::graph::get_or_insert_default::Error),
+pub type Error = Simple;
+
+/// A simple error type for merge base operations.
+#[derive(Debug)]
+pub struct Simple(pub &'static str);
+
+impl std::fmt::Display for Simple {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.0)
+    }
 }
 
+impl std::error::Error for Simple {}
+
 pub(crate) mod function;
 
 mod octopus {
diff --git a/gix-revision/src/spec/parse/delegate.rs b/gix-revision/src/spec/parse/delegate.rs
index 3ff9039e991..870a3dc675f 100644
--- a/gix-revision/src/spec/parse/delegate.rs
+++ b/gix-revision/src/spec/parse/delegate.rs
@@ -1,4 +1,5 @@
 use bstr::BStr;
+use gix_error::Exn;
 
 /// Usually the first methods to call when parsing a rev-spec to set an anchoring revision (which is typically a `Commit` object).
 /// Methods can be called multiple time to either try input or to parse another rev-spec that is part of a range.
@@ -11,22 +12,22 @@ pub trait Revision {
     /// Resolve `name` as reference which might not be a valid reference name. The name may be partial like `main` or full like
     /// `refs/heads/main` solely depending on the users input.
     /// Symbolic referenced should be followed till their object, but objects **must not yet** be peeled.
-    fn find_ref(&mut self, name: &BStr) -> Option<()>;
+    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn>;
 
     /// An object prefix to disambiguate, returning `None` if it is ambiguous or wasn't found at all.
     ///
     /// If `hint` is set, it should be used to disambiguate multiple objects with the same prefix.
-    fn disambiguate_prefix(&mut self, prefix: gix_hash::Prefix, hint: Option<PrefixHint<'_>>) -> Option<()>;
+    fn disambiguate_prefix(&mut self, prefix: gix_hash::Prefix, hint: Option<PrefixHint<'_>>) -> Result<(), Exn>;
 
     /// Lookup the reflog of the previously set reference, or dereference `HEAD` to its reference
     /// to obtain the ref name (as opposed to `HEAD` itself).
     /// If there is no such reflog entry, return `None`.
-    fn reflog(&mut self, query: ReflogLookup) -> Option<()>;
+    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn>;
 
     /// When looking at `HEAD`, `branch_no` is the non-null checkout in the path, e.g. `1` means the last branch checked out,
     /// `2` is the one before that.
     /// Return `None` if there is no branch as the checkout history (via the reflog) isn't long enough.
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Option<()>;
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn>;
 
     /// Lookup the previously set branch or dereference `HEAD` to its reference to use its name to lookup the sibling branch of `kind`
     /// in the configuration (typically in `refs/remotes/…`). The sibling branches are always local tracking branches.
@@ -34,7 +35,7 @@ pub trait Revision {
     /// of `refs/heads/`.
     /// Note that the caller isn't aware if the previously set reference is a branch or not and might call this method even though no reference
     /// is known.
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Option<()>;
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn>;
 }
 
 /// Combine one or more specs into a range of multiple.
@@ -48,16 +49,16 @@ pub trait Kind {
     /// and no second specification is provided.
     ///
     /// Note that the method can be called even if other invariants are not fulfilled, treat these as errors.
-    fn kind(&mut self, kind: crate::spec::Kind) -> Option<()>;
+    fn kind(&mut self, kind: crate::spec::Kind) -> Result<(), Exn>;
 }
 
 /// Once an anchor is set one can adjust it using traversal methods.
 pub trait Navigate {
     /// Adjust the current revision to traverse the graph according to `kind`.
-    fn traverse(&mut self, kind: Traversal) -> Option<()>;
+    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn>;
 
     /// Peel the current object until it reached `kind` or `None` if the chain does not contain such object.
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Option<()>;
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn>;
 
     /// Find the first revision/commit whose message matches the given `regex` (which is never empty).
     /// to see how it should be matched.
@@ -65,7 +66,7 @@ pub trait Navigate {
     ///
     /// If no revision is known yet, find the _youngest_ matching commit from _any_ reference, including `HEAD`.
     /// Otherwise, only find commits reachable from the currently set revision.
-    fn find(&mut self, regex: &BStr, negated: bool) -> Option<()>;
+    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn>;
 
     /// Look up the given `path` at the given `stage` in the index returning its blob id,
     /// or return `None` if it doesn't exist at this `stage`.
@@ -74,7 +75,7 @@ pub trait Navigate {
     /// * `stage` ranges from 0 to 2, with 0 being the base, 1 being ours, 2 being theirs.
     /// * `path` without prefix is relative to the root of the repository, while prefixes like `./` and `../` make it
     ///   relative to the current working directory.
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()>;
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn>;
 }
 
 /// A hint to make disambiguation when looking up prefixes possible.
diff --git a/gix-revision/src/spec/parse/function.rs b/gix-revision/src/spec/parse/function.rs
index 9941c993499..10f9660ee91 100644
--- a/gix-revision/src/spec/parse/function.rs
+++ b/gix-revision/src/spec/parse/function.rs
@@ -1,11 +1,11 @@
 use std::{str::FromStr, time::SystemTime};
 
-use bstr::{BStr, BString, ByteSlice, ByteVec};
-
 use crate::{
     spec,
     spec::parse::{delegate, delegate::SiblingBranch, Delegate, Error},
 };
+use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_error::{ErrorExt, Exn, ResultExt};
 
 /// Parse a git [`revspec`](https://git-scm.com/docs/git-rev-parse#_specifying_revisions) and call `delegate` for each token
 /// successfully parsed.
@@ -13,14 +13,16 @@ use crate::{
 /// Note that the `delegate` is expected to maintain enough state to lookup revisions properly.
 /// Returns `Ok(())` if all of `input` was consumed, or the error if either the `revspec` syntax was incorrect or
 /// the `delegate` failed to perform the request.
-pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Error> {
+pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Exn<Error>> {
     use delegate::{Kind, Revision};
     let mut delegate = InterceptRev::new(delegate);
     let mut prev_kind = None;
     if let Some(b'^') = input.first() {
         input = next(input).1;
         let kind = spec::Kind::ExcludeReachable;
-        delegate.kind(kind).ok_or(Error::Delegate)?;
+        delegate
+            .kind(kind)
+            .or_raise(|| Error::new(format!("delegate.kind({kind:?}) failed")))?;
         prev_kind = kind.into();
     }
 
@@ -33,38 +35,48 @@ pub fn parse(mut input: &BStr, delegate: &mut impl Delegate) -> Result<(), Error
         return if input.is_empty() {
             Ok(())
         } else {
-            Err(Error::UnconsumedInput { input: input.into() })
+            Err(Error::new_with_input("unconsumed input", input).raise())
         };
     }
     if let Some((rest, kind)) = try_range(input) {
         if let Some(prev_kind) = prev_kind {
-            return Err(Error::KindSetTwice { prev_kind, kind });
+            return Err(Error::new(format!(
+                "cannot set spec kind more than once (was {prev_kind:?}, now {kind:?})"
+            ))
+            .raise());
         }
         if !found_revision {
-            delegate.find_ref("HEAD".into()).ok_or(Error::Delegate)?;
+            delegate
+                .find_ref("HEAD".into())
+                .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
         }
-        delegate.kind(kind).ok_or(Error::Delegate)?;
+        delegate
+            .kind(kind)
+            .or_raise(|| Error::new(format!("delegate.kind({kind:?}) failed")))?;
         (input, found_revision) = {
             let remainder = revision(rest.as_bstr(), &mut delegate)?;
             (remainder, remainder != rest)
         };
         if !found_revision {
-            delegate.find_ref("HEAD".into()).ok_or(Error::Delegate)?;
+            delegate
+                .find_ref("HEAD".into())
+                .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
         }
     }
 
     if input.is_empty() {
-        delegate.done();
-        Ok(())
+        delegate
+            .done()
+            .or_raise(|| Error::new("No revision was produced after all input was consumed"))
     } else {
-        Err(Error::UnconsumedInput { input: input.into() })
+        Err(Error::new_with_input("unconsumed input", input).raise())
     }
 }
 
 mod intercept {
-    use bstr::{BStr, BString};
-
     use crate::spec::parse::{delegate, Delegate};
+    use bstr::{BStr, BString};
+    use gix_error::Exn;
 
     #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
     pub(crate) enum PrefixHintOwned {
@@ -121,9 +133,9 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn done(&mut self) {
+        fn done(&mut self) -> Result<(), Exn> {
             self.done = true;
-            self.inner.done();
+            self.inner.done()
         }
     }
 
@@ -131,7 +143,7 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn find_ref(&mut self, name: &BStr) -> Option<()> {
+        fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
             self.last_ref = name.to_owned().into();
             self.inner.find_ref(name)
         }
@@ -140,20 +152,20 @@ mod intercept {
             &mut self,
             prefix: gix_hash::Prefix,
             hint: Option<delegate::PrefixHint<'_>>,
-        ) -> Option<()> {
+        ) -> Result<(), Exn> {
             self.last_prefix = Some((prefix, hint.map(Into::into)));
             self.inner.disambiguate_prefix(prefix, hint)
         }
 
-        fn reflog(&mut self, query: delegate::ReflogLookup) -> Option<()> {
+        fn reflog(&mut self, query: delegate::ReflogLookup) -> Result<(), Exn> {
             self.inner.reflog(query)
         }
 
-        fn nth_checked_out_branch(&mut self, branch_no: usize) -> Option<()> {
+        fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
             self.inner.nth_checked_out_branch(branch_no)
         }
 
-        fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Option<()> {
+        fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Result<(), Exn> {
             self.inner.sibling_branch(kind)
         }
     }
@@ -162,19 +174,19 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn traverse(&mut self, kind: delegate::Traversal) -> Option<()> {
+        fn traverse(&mut self, kind: delegate::Traversal) -> Result<(), Exn> {
             self.inner.traverse(kind)
         }
 
-        fn peel_until(&mut self, kind: delegate::PeelTo<'_>) -> Option<()> {
+        fn peel_until(&mut self, kind: delegate::PeelTo<'_>) -> Result<(), Exn> {
             self.inner.peel_until(kind)
         }
 
-        fn find(&mut self, regex: &BStr, negated: bool) -> Option<()> {
+        fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
             self.inner.find(regex, negated)
         }
 
-        fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+        fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
             self.inner.index_lookup(path, stage)
         }
     }
@@ -183,17 +195,47 @@ mod intercept {
     where
         T: Delegate,
     {
-        fn kind(&mut self, kind: crate::spec::Kind) -> Option<()> {
+        fn kind(&mut self, kind: crate::spec::Kind) -> Result<(), Exn> {
             self.inner.kind(kind)
         }
     }
 }
 use intercept::InterceptRev;
 
-fn try_set_prefix(delegate: &mut impl Delegate, hex_name: &BStr, hint: Option<delegate::PrefixHint<'_>>) -> Option<()> {
+trait ResultExt2 {
+    fn or_else_none<F>(self, f: F) -> Option<()>
+    where
+        F: FnOnce(Exn);
+}
+
+impl ResultExt2 for Result<(), Exn> {
+    fn or_else_none<F>(self, f: F) -> Option<()>
+    where
+        F: FnOnce(Exn),
+    {
+        match self {
+            Ok(()) => Some(()),
+            Err(err) => {
+                f(err);
+                None
+            }
+        }
+    }
+}
+
+fn try_set_prefix(
+    delegate: &mut impl Delegate,
+    hex_name: &BStr,
+    hint: Option<delegate::PrefixHint<'_>>,
+    errors: &mut Vec<Exn>,
+) -> Option<()> {
     gix_hash::Prefix::from_hex(hex_name.to_str().expect("hexadecimal only"))
         .ok()
-        .and_then(|prefix| delegate.disambiguate_prefix(prefix, hint))
+        .and_then(|prefix| {
+            delegate
+                .disambiguate_prefix(prefix, hint)
+                .or_else_none(|err| errors.push(err))
+        })
 }
 
 fn long_describe_prefix(name: &BStr) -> Option<(&BStr, delegate::PrefixHint<'_>)> {
@@ -296,7 +338,7 @@ fn parens(input: &[u8]) -> Result<Option<InsideParensRestConsumed<'_>>, Error> {
             return Ok(Some((inner, input[idx + 1..].as_bstr(), idx + 1)));
         }
     }
-    Err(Error::UnclosedBracePair { input: input.into() })
+    Err(Error::new_with_input("unclosed brace pair", input))
 }
 
 fn try_parse<T: FromStr + PartialEq + Default>(input: &BStr) -> Result<Option<T>, Error> {
@@ -306,7 +348,10 @@ fn try_parse<T: FromStr + PartialEq + Default>(input: &BStr) -> Result<Option<T>
         .and_then(|n| {
             n.parse().ok().map(|n| {
                 if n == T::default() && input[0] == b'-' {
-                    return Err(Error::NegativeZero { input: input.into() });
+                    return Err(Error::new_with_input(
+                        "negative zero is invalid - remove the minus sign",
+                        input,
+                    ));
                 }
                 Ok(n)
             })
@@ -314,28 +359,50 @@ fn try_parse<T: FromStr + PartialEq + Default>(input: &BStr) -> Result<Option<T>
         .transpose()
 }
 
-fn revision<'a, T>(mut input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Error>
+fn revision<'a, T>(mut input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Exn<Error>>
 where
     T: Delegate,
 {
     use delegate::{Navigate, Revision};
-    fn consume_all(res: Option<()>) -> Result<&'static BStr, Error> {
-        res.ok_or(Error::Delegate).map(|_| "".into())
+    fn consume_all(res: Result<(), Exn>, err: impl FnOnce() -> String) -> Result<&'static BStr, Exn<Error>> {
+        res.map(|_| "".into()).or_raise(|| Error::new(err()))
     }
     match input.as_bytes() {
-        [b':'] => return Err(Error::MissingColonSuffix),
-        [b':', b'/'] => return Err(Error::EmptyTopLevelRegex),
+        [b':'] => {
+            return Err(
+                Error::new("':' must be followed by either slash and regex or path to lookup in HEAD tree").raise(),
+            )
+        }
+        [b':', b'/'] => return Err(Error::new("':/' must be followed by a regular expression").raise()),
         [b':', b'/', regex @ ..] => {
             let (regex, negated) = parse_regex_prefix(regex.as_bstr())?;
             if regex.is_empty() {
-                return Err(Error::UnconsumedInput { input: input.into() });
+                return Err(Error::new_with_input("unconsumed input", input).raise());
             }
-            return consume_all(delegate.find(regex, negated));
+            return consume_all(delegate.find(regex, negated), || {
+                format!("Delegate couldn't find '{regex}' (negated: {negated})")
+            });
+        }
+        [b':', b'0', b':', path @ ..] => {
+            return consume_all(delegate.index_lookup(path.as_bstr(), 0), || {
+                format!("Couldn't find index '{path}' stage 0", path = path.as_bstr())
+            })
+        }
+        [b':', b'1', b':', path @ ..] => {
+            return consume_all(delegate.index_lookup(path.as_bstr(), 1), || {
+                format!("Couldn't find index '{path}' stage 1", path = path.as_bstr())
+            })
+        }
+        [b':', b'2', b':', path @ ..] => {
+            return consume_all(delegate.index_lookup(path.as_bstr(), 2), || {
+                format!("Couldn't find index '{path}' stage 2", path = path.as_bstr())
+            })
+        }
+        [b':', path @ ..] => {
+            return consume_all(delegate.index_lookup(path.as_bstr(), 0), || {
+                format!("Couldn't find index '{path}' stage 0 (implicit)", path = path.as_bstr())
+            })
         }
-        [b':', b'0', b':', path @ ..] => return consume_all(delegate.index_lookup(path.as_bstr(), 0)),
-        [b':', b'1', b':', path @ ..] => return consume_all(delegate.index_lookup(path.as_bstr(), 1)),
-        [b':', b'2', b':', path @ ..] => return consume_all(delegate.index_lookup(path.as_bstr(), 2)),
-        [b':', path @ ..] => return consume_all(delegate.index_lookup(path.as_bstr(), 0)),
         _ => {}
     }
 
@@ -382,103 +449,116 @@ where
     let mut sep = sep_pos.map(|pos| input[pos]);
     let mut has_ref_or_implied_name = name.is_empty();
     if name.is_empty() && sep == Some(b'@') && sep_pos.and_then(|pos| input.get(pos + 1)) != Some(&b'{') {
-        delegate.find_ref("HEAD".into()).ok_or(Error::Delegate)?;
+        delegate
+            .find_ref("HEAD".into())
+            .or_raise(|| Error::new("delegate did not find the HEAD reference"))?;
         sep_pos = sep_pos.map(|pos| pos + 1);
         sep = match sep_pos.and_then(|pos| input.get(pos).copied()) {
             None => return Ok("".into()),
             Some(pos) => Some(pos),
         };
     } else {
+        let mut errors = Vec::new();
         (consecutive_hex_chars.unwrap_or(0) >= gix_hash::Prefix::MIN_HEX_LEN)
-            .then(|| try_set_prefix(delegate, name, None))
+            .then(|| try_set_prefix(delegate, name, None, &mut errors))
             .flatten()
             .or_else(|| {
                 let (prefix, hint) = long_describe_prefix(name)
                     .map(|(c, h)| (c, Some(h)))
                     .or_else(|| short_describe_prefix(name).map(|c| (c, None)))?;
-                try_set_prefix(delegate, prefix, hint)
+                try_set_prefix(delegate, prefix, hint, &mut errors)
             })
             .or_else(|| {
                 name.is_empty().then_some(()).or_else(|| {
                     #[allow(clippy::let_unit_value)]
                     {
-                        let res = delegate.find_ref(name)?;
+                        let res = delegate.find_ref(name).or_else_none(|err| {
+                            errors.push(err);
+                        })?;
                         has_ref_or_implied_name = true;
                         res.into()
                     }
                 })
             })
-            .ok_or(Error::Delegate)?;
+            .ok_or_else(|| Error::new_with_input("couldn't parse revision", input).raise_iter(errors))?;
     }
 
     input = {
         if let Some(b'@') = sep {
             let past_sep = input[sep_pos.map_or(input.len(), |pos| pos + 1)..].as_bstr();
-            let (nav, rest, _consumed) = parens(past_sep)?.ok_or_else(|| Error::AtNeedsCurlyBrackets {
-                input: input[sep_pos.unwrap_or(input.len())..].into(),
+            let (nav, rest, _consumed) = parens(past_sep)?.ok_or_else(|| {
+                Error::new_with_input(
+                    "@ character must be standalone or followed by {<content>}",
+                    &input[sep_pos.unwrap_or(input.len())..],
+                )
             })?;
             let nav = nav.as_ref();
             if let Some(n) = try_parse::<isize>(nav)? {
                 if n < 0 {
                     if name.is_empty() {
-                        delegate
-                            .nth_checked_out_branch(n.unsigned_abs())
-                            .ok_or(Error::Delegate)?;
+                        delegate.nth_checked_out_branch(n.unsigned_abs()).or_raise(|| {
+                            Error::new_with_input(
+                                format!("delegate.nth_checked_out_branch({n:?}) didn't find a branch"),
+                                nav,
+                            )
+                        })?;
                     } else {
-                        return Err(Error::RefnameNeedsPositiveReflogEntries { nav: nav.into() });
+                        return Err(Error::new_with_input(
+                            "reference name must be followed by positive numbers in @{n}",
+                            nav,
+                        )
+                        .raise());
                     }
                 } else if has_ref_or_implied_name {
+                    let lookup = if n >= 100000000 {
+                        let time = nav
+                            .to_str()
+                            .or_raise(|| Error::new_with_input("could not parse time for reflog lookup", nav))
+                            .and_then(|date| {
+                                gix_date::parse(date, None)
+                                    .or_raise(|| Error::new_with_input("could not parse time for reflog lookup", nav))
+                            })?;
+                        delegate::ReflogLookup::Date(time)
+                    } else {
+                        delegate::ReflogLookup::Entry(n.try_into().expect("non-negative isize fits usize"))
+                    };
                     delegate
-                        .reflog(if n >= 100000000 {
-                            let time = nav
-                                .to_str()
-                                .map_err(|_| Error::Time {
-                                    input: nav.into(),
-                                    source: None,
-                                })
-                                .and_then(|date| {
-                                    gix_date::parse(date, None).map_err(|err| Error::Time {
-                                        input: nav.into(),
-                                        source: err.into(),
-                                    })
-                                })?;
-                            delegate::ReflogLookup::Date(time)
-                        } else {
-                            delegate::ReflogLookup::Entry(n.try_into().expect("non-negative isize fits usize"))
-                        })
-                        .ok_or(Error::Delegate)?;
+                        .reflog(lookup)
+                        .or_raise(|| Error::new_with_input(format!("delegate.reflog({lookup:?}) failed"), nav))?;
                 } else {
-                    return Err(Error::ReflogLookupNeedsRefName { name: (*name).into() });
+                    return Err(Error::new_with_input("reflog entries require a ref name", *name).raise());
                 }
             } else if let Some(kind) = SiblingBranch::parse(nav) {
                 if has_ref_or_implied_name {
-                    delegate.sibling_branch(kind).ok_or(Error::Delegate)
+                    delegate
+                        .sibling_branch(kind)
+                        .or_raise(|| Error::new_with_input(format!("delegate.sibling_branch({kind:?}) failed"), nav))
                 } else {
-                    Err(Error::SiblingBranchNeedsBranchName { name: (*name).into() })
+                    Err(Error::new_with_input(
+                        "sibling branches like 'upstream' or 'push' require a branch name with remote configuration",
+                        *name,
+                    )
+                    .raise())
                 }?;
             } else if has_ref_or_implied_name {
                 let time = nav
                     .to_str()
-                    .map_err(|_| Error::Time {
-                        input: nav.into(),
-                        source: None,
-                    })
+                    .map_err(|_| Error::new_with_input("could not parse time for reflog lookup", nav))
                     .and_then(|date| {
-                        gix_date::parse(date, Some(SystemTime::now())).map_err(|err| Error::Time {
-                            input: nav.into(),
-                            source: err.into(),
-                        })
+                        gix_date::parse(date, Some(SystemTime::now()))
+                            .map_err(|_| Error::new_with_input("could not parse time for reflog lookup", nav))
                     })?;
+                let lookup = delegate::ReflogLookup::Date(time);
                 delegate
-                    .reflog(delegate::ReflogLookup::Date(time))
-                    .ok_or(Error::Delegate)?;
+                    .reflog(lookup)
+                    .or_raise(|| Error::new_with_input(format!("delegate.reflog({lookup:?}) failed"), nav))?;
             } else {
-                return Err(Error::ReflogLookupNeedsRefName { name: (*name).into() });
+                return Err(Error::new_with_input("reflog entries require a ref name", *name).raise());
             }
             rest
         } else {
             if sep_pos == Some(0) && sep == Some(b'~') {
-                return Err(Error::MissingTildeAnchor);
+                return Err(Error::new("tilde needs to follow an anchor, like @~").raise());
             }
             input[sep_pos.unwrap_or(input.len())..].as_bstr()
         }
@@ -487,12 +567,13 @@ where
     navigate(input, delegate)
 }
 
-fn navigate<'a, T>(input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Error>
+fn navigate<'a, T>(input: &'a BStr, delegate: &mut InterceptRev<'_, T>) -> Result<&'a BStr, Exn<Error>>
 where
     T: Delegate,
 {
     use delegate::{Kind, Navigate, Revision};
     let mut cursor = 0;
+    let done_msg = "navigation succeeded, but no revision was produced as intermediate step";
     while let Some(b) = input.get(cursor) {
         cursor += 1;
         match *b {
@@ -503,9 +584,10 @@ where
                     .transpose()?
                     .unwrap_or((1, 0));
                 if number != 0 {
-                    delegate
-                        .traverse(delegate::Traversal::NthAncestor(number))
-                        .ok_or(Error::Delegate)?;
+                    let traversal = delegate::Traversal::NthAncestor(number);
+                    delegate.traverse(traversal).or_raise(|| {
+                        Error::new_with_input(format!("delegate.traverse({traversal:?}) failed"), input)
+                    })?;
                 }
                 cursor += consumed;
             }
@@ -516,34 +598,53 @@ where
                     .transpose()?
                 {
                     if negative {
-                        delegate
-                            .traverse(delegate::Traversal::NthParent(
-                                number
-                                    .checked_mul(-1)
-                                    .ok_or_else(|| Error::InvalidNumber {
-                                        input: past_sep.expect("present").into(),
-                                    })?
-                                    .try_into()
-                                    .expect("non-negative"),
-                            ))
-                            .ok_or(Error::Delegate)?;
-                        delegate.kind(spec::Kind::RangeBetween).ok_or(Error::Delegate)?;
+                        let traversal = delegate::Traversal::NthParent(
+                            number
+                                .checked_mul(-1)
+                                .ok_or_else(|| {
+                                    Error::new_with_input("could not parse number", past_sep.expect("present"))
+                                })?
+                                .try_into()
+                                .expect("non-negative"),
+                        );
+                        delegate.traverse(traversal).or_raise(|| {
+                            Error::new_with_input(
+                                "delegate.traverse({traversal:?}) failed",
+                                past_sep.unwrap_or_default(),
+                            )
+                        })?;
+                        let kind = spec::Kind::RangeBetween;
+                        delegate.kind(kind).or_raise(|| {
+                            Error::new_with_input(
+                                format!("delegate.kind({kind:?}) failed"),
+                                past_sep.unwrap_or_default(),
+                            )
+                        })?;
                         if let Some((prefix, hint)) = delegate.last_prefix.take() {
-                            match hint {
+                            match &hint {
                                 Some(hint) => delegate.disambiguate_prefix(prefix, hint.to_ref().into()),
                                 None => delegate.disambiguate_prefix(prefix, None),
                             }
-                            .ok_or(Error::Delegate)?;
+                            .or_raise(|| {
+                                Error::new_with_input(
+                                    format!("delegate.disambiguate_prefix({hint:?}) failed"),
+                                    past_sep.unwrap_or_default(),
+                                )
+                            })?;
                         } else if let Some(name) = delegate.last_ref.take() {
-                            delegate.find_ref(name.as_bstr()).ok_or(Error::Delegate)?;
+                            delegate.find_ref(name.as_bstr()).or_raise(|| {
+                                Error::new_with_input(
+                                    format!("delegate.find_ref({name}) failed"),
+                                    past_sep.unwrap_or_default(),
+                                )
+                            })?;
                         } else {
-                            return Err(Error::UnconsumedInput {
-                                input: input[cursor..].into(),
-                            });
+                            return Err(Error::new_with_input("unconsumed input", &input[cursor..]).raise());
                         }
-                        delegate.done();
                         cursor += consumed;
-                        return Ok(input[cursor..].as_bstr());
+                        let rest = input[cursor..].as_bstr();
+                        delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                        return Ok(rest);
                     } else if number == 0 {
                         delegate.peel_until(delegate::PeelTo::ObjectKind(gix_object::Kind::Commit))
                     } else {
@@ -551,7 +652,7 @@ where
                             number.try_into().expect("positive number"),
                         ))
                     }
-                    .ok_or(Error::Delegate)?;
+                    .or_raise(|| Error::new_with_input("unknown navigation", past_sep.unwrap_or_default()))?;
                     cursor += consumed;
                 } else if let Some((kind, _rest, consumed)) =
                     past_sep.and_then(|past_sep| parens(past_sep).transpose()).transpose()?
@@ -567,35 +668,51 @@ where
                         regex if regex.starts_with(b"/") => {
                             let (regex, negated) = parse_regex_prefix(regex[1..].as_bstr())?;
                             if !regex.is_empty() {
-                                delegate.find(regex, negated).ok_or(Error::Delegate)?;
+                                delegate.find(regex, negated).or_raise(|| {
+                                    Error::new(format!("Delegate couldn't find '{regex}' (negated: {negated})"))
+                                })?;
                             }
                             continue;
                         }
-                        invalid => return Err(Error::InvalidObject { input: invalid.into() }),
+                        invalid => return Err(Error::new_with_input("cannot peel to unknown target", invalid).raise()),
                     };
-                    delegate.peel_until(target).ok_or(Error::Delegate)?;
+                    delegate.peel_until(target).or_raise(|| {
+                        Error::new_with_input(
+                            format!("delegate.peel_until({target:?}) failed"),
+                            past_sep.unwrap_or_default(),
+                        )
+                    })?;
                 } else if past_sep.and_then(<[_]>::first) == Some(&b'!') {
+                    let rest = input[cursor + 1..].as_bstr();
+                    let kind = spec::Kind::ExcludeReachableFromParents;
                     delegate
-                        .kind(spec::Kind::ExcludeReachableFromParents)
-                        .ok_or(Error::Delegate)?;
-                    delegate.done();
-                    return Ok(input[cursor + 1..].as_bstr());
+                        .kind(kind)
+                        .or_raise(|| Error::new_with_input(format!("delegate.kind({kind:?}) failed"), rest))?;
+                    delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                    return Ok(rest);
                 } else if past_sep.and_then(<[_]>::first) == Some(&b'@') {
+                    let rest = input[cursor + 1..].as_bstr();
+                    let kind = spec::Kind::IncludeReachableFromParents;
                     delegate
-                        .kind(spec::Kind::IncludeReachableFromParents)
-                        .ok_or(Error::Delegate)?;
-                    delegate.done();
-                    return Ok(input[cursor + 1..].as_bstr());
+                        .kind(kind)
+                        .or_raise(|| Error::new_with_input(format!("delegate.kind({kind:?}) failed"), rest))?;
+                    delegate.done().or_raise(|| Error::new_with_input(done_msg, rest))?;
+                    return Ok(rest);
                 } else {
-                    delegate
-                        .traverse(delegate::Traversal::NthParent(1))
-                        .ok_or(Error::Delegate)?;
+                    let parent = delegate::Traversal::NthParent(1);
+                    delegate.traverse(parent).or_raise(|| {
+                        Error::new_with_input(
+                            format!("delegate.parent({parent:?}) failed",),
+                            past_sep.unwrap_or_default(),
+                        )
+                    })?;
                 }
             }
             b':' => {
+                let to = delegate::PeelTo::Path(input[cursor..].as_bstr());
                 delegate
-                    .peel_until(delegate::PeelTo::Path(input[cursor..].as_bstr()))
-                    .ok_or(Error::Delegate)?;
+                    .peel_until(to)
+                    .or_raise(|| Error::new(format!("delegate.peel_until({to:?}) failed")))?;
                 return Ok("".into());
             }
             _ => return Ok(input[cursor - 1..].as_bstr()),
@@ -608,7 +725,7 @@ fn parse_regex_prefix(regex: &BStr) -> Result<(&BStr, bool), Error> {
     Ok(match regex.strip_prefix(b"!") {
         Some(regex) if regex.first() == Some(&b'!') => (regex.as_bstr(), false),
         Some(regex) if regex.first() == Some(&b'-') => (regex[1..].as_bstr(), true),
-        Some(_regex) => return Err(Error::UnspecifiedRegexModifier { regex: regex.into() }),
+        Some(_regex) => return Err(Error::new_with_input("need one character after /!, typically -", regex)),
         None => (regex, false),
     })
 }
@@ -616,21 +733,27 @@ fn parse_regex_prefix(regex: &BStr) -> Result<(&BStr, bool), Error> {
 fn try_parse_usize(input: &BStr) -> Result<Option<(usize, usize)>, Error> {
     let mut bytes = input.iter().peekable();
     if bytes.peek().filter(|&&&b| b == b'-' || b == b'+').is_some() {
-        return Err(Error::SignedNumber { input: input.into() });
+        return Err(Error::new_with_input(
+            "negative or explicitly positive numbers are invalid here",
+            input,
+        ));
     }
     let num_digits = bytes.take_while(|b| b.is_ascii_digit()).count();
     if num_digits == 0 {
         return Ok(None);
     }
     let input = &input[..num_digits];
-    let number = try_parse(input)?.ok_or_else(|| Error::InvalidNumber { input: input.into() })?;
+    let number = try_parse(input)?.ok_or_else(|| Error::new_with_input("could not parse number", input))?;
     Ok(Some((number, num_digits)))
 }
 
 fn try_parse_isize(input: &BStr) -> Result<Option<(isize, bool, usize)>, Error> {
     let mut bytes = input.iter().peekable();
     if bytes.peek().filter(|&&&b| b == b'+').is_some() {
-        return Err(Error::SignedNumber { input: input.into() });
+        return Err(Error::new_with_input(
+            "explicitly positive numbers are invalid here",
+            input,
+        ));
     }
     let negative = bytes.peek() == Some(&&b'-');
     let num_digits = bytes.take_while(|b| b.is_ascii_digit() || *b == &b'-').count();
@@ -640,7 +763,7 @@ fn try_parse_isize(input: &BStr) -> Result<Option<(isize, bool, usize)>, Error>
         return Ok(Some((-1, negative, num_digits)));
     }
     let input = &input[..num_digits];
-    let number = try_parse(input)?.ok_or_else(|| Error::InvalidNumber { input: input.into() })?;
+    let number = try_parse(input)?.ok_or_else(|| Error::new_with_input("could not parse number", input))?;
     Ok(Some((number, negative, num_digits)))
 }
 
diff --git a/gix-revision/src/spec/parse/mod.rs b/gix-revision/src/spec/parse/mod.rs
index 5a64012c666..41a5ad0be2c 100644
--- a/gix-revision/src/spec/parse/mod.rs
+++ b/gix-revision/src/spec/parse/mod.rs
@@ -1,49 +1,6 @@
-use bstr::BString;
-
-use crate::spec;
-
-/// The error returned by [`spec::parse()`][crate::spec::parse()].
-#[derive(Debug, thiserror::Error)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("'~' needs to follow an anchor, like '@~'.")]
-    MissingTildeAnchor,
-    #[error("':' needs to be followed by either '/' and regex or the path to lookup in the HEAD tree.")]
-    MissingColonSuffix,
-    #[error("':/' must be followed by a regular expression.")]
-    EmptyTopLevelRegex,
-    #[error("Need one character after '/!', typically '-', but got {:?}", .regex)]
-    UnspecifiedRegexModifier { regex: BString },
-    #[error("Cannot peel to {:?} - unknown target.", .input)]
-    InvalidObject { input: BString },
-    #[error("Could not parse time {:?} for revlog lookup.", .input)]
-    Time {
-        input: BString,
-        source: Option<gix_date::parse::Error>,
-    },
-    #[error("Sibling branches like 'upstream' or 'push' require a branch name with remote configuration, got {:?}", .name)]
-    SiblingBranchNeedsBranchName { name: BString },
-    #[error("Reflog entries require a ref name, got {:?}", .name)]
-    ReflogLookupNeedsRefName { name: BString },
-    #[error("A reference name must be followed by positive numbers in '@{{n}}', got {:?}", .nav)]
-    RefnameNeedsPositiveReflogEntries { nav: BString },
-    #[error("Negative or explicitly positive numbers are invalid here: {:?}", .input)]
-    SignedNumber { input: BString },
-    #[error("Could not parse number from {input:?}")]
-    InvalidNumber { input: BString },
-    #[error("Negative zeroes are invalid: {:?} - remove the '-'", .input)]
-    NegativeZero { input: BString },
-    #[error("The opening brace in {:?} was not matched", .input)]
-    UnclosedBracePair { input: BString },
-    #[error("Cannot set spec kind more than once. Previous value was {:?}, now it is {:?}", .prev_kind, .kind)]
-    KindSetTwice { prev_kind: spec::Kind, kind: spec::Kind },
-    #[error("The @ character is either standing alone or followed by `{{<content>}}`, got {:?}", .input)]
-    AtNeedsCurlyBrackets { input: BString },
-    #[error("A portion of the input could not be parsed: {:?}", .input)]
-    UnconsumedInput { input: BString },
-    #[error("The delegate didn't indicate success - check delegate for more information")]
-    Delegate,
-}
+use gix_error::Exn;
+/// The error returned by [`spec::parse()`](crate::spec::parse()).
+pub use gix_error::ParseError as Error;
 
 ///
 pub mod delegate;
@@ -58,7 +15,7 @@ pub trait Delegate: delegate::Revision + delegate::Navigate + delegate::Kind {
     /// It can be used as a marker to finalize internal data structures.
     ///
     /// Note that it will not be called if there is unconsumed input.
-    fn done(&mut self);
+    fn done(&mut self) -> Result<(), Exn>;
 }
 
 pub(crate) mod function;
diff --git a/gix-revision/tests/revision/describe/mod.rs b/gix-revision/tests/revision/describe/mod.rs
index e541c2fde4e..86f1895b59c 100644
--- a/gix-revision/tests/revision/describe/mod.rs
+++ b/gix-revision/tests/revision/describe/mod.rs
@@ -1,10 +1,10 @@
-use std::{borrow::Cow, path::PathBuf};
-
+use gix_error::Exn;
 use gix_object::bstr::ByteSlice;
 use gix_revision::{
     describe,
     describe::{Error, Outcome},
 };
+use std::{borrow::Cow, path::PathBuf};
 
 use crate::hex_to_id;
 
@@ -13,8 +13,11 @@ mod format;
 fn run_test(
     transform_odb: impl FnOnce(gix_odb::Handle) -> gix_odb::Handle,
     options: impl Fn(gix_hash::ObjectId) -> gix_revision::describe::Options<'static>,
-    run_assertions: impl Fn(Result<Option<Outcome<'static>>, Error>, gix_hash::ObjectId) -> crate::Result,
-) -> crate::Result {
+    run_assertions: impl Fn(
+        Result<Option<Outcome<'static>>, Exn<Error>>,
+        gix_hash::ObjectId,
+    ) -> Result<(), gix_error::Error>,
+) -> Result<(), gix_error::Error> {
     let store = odb_at(".");
     let store = transform_odb(store);
     let commit_id = hex_to_id("01ec18a3ebf2855708ad3c9d244306bc1fae3e9b");
@@ -32,7 +35,7 @@ fn run_test(
 }
 
 #[test]
-fn option_none_if_no_tag_found() -> crate::Result {
+fn option_none_if_no_tag_found() -> Result<(), gix_error::Error> {
     run_test(
         std::convert::identity,
         |_| Default::default(),
@@ -44,7 +47,7 @@ fn option_none_if_no_tag_found() -> crate::Result {
 }
 
 #[test]
-fn fallback_if_configured_in_options_but_no_candidate_or_names() -> crate::Result {
+fn fallback_if_configured_in_options_but_no_candidate_or_names() -> Result<(), gix_error::Error> {
     run_test(
         std::convert::identity,
         |_| describe::Options {
@@ -66,7 +69,7 @@ fn fallback_if_configured_in_options_but_no_candidate_or_names() -> crate::Resul
 }
 
 #[test]
-fn fallback_if_configured_in_options_and_max_candidates_zero() -> crate::Result {
+fn fallback_if_configured_in_options_and_max_candidates_zero() -> Result<(), gix_error::Error> {
     run_test(
         std::convert::identity,
         |_| describe::Options {
@@ -86,7 +89,7 @@ fn fallback_if_configured_in_options_and_max_candidates_zero() -> crate::Result
 }
 
 #[test]
-fn not_enough_candidates() -> crate::Result {
+fn not_enough_candidates() -> Result<(), gix_error::Error> {
     let name = Cow::Borrowed(b"at-c5".as_bstr());
     run_test(
         std::convert::identity,
@@ -118,7 +121,7 @@ fn not_enough_candidates() -> crate::Result {
 }
 
 #[test]
-fn typical_usecases() -> crate::Result {
+fn typical_usecases() -> Result<(), gix_error::Error> {
     let name = Cow::Borrowed(b"main".as_bstr());
     run_test(
         std::convert::identity,
@@ -198,7 +201,7 @@ fn typical_usecases() -> crate::Result {
 }
 
 #[test]
-fn shallow_yields_no_result_if_provided_refs_are_in_truncated_part_of_history() -> crate::Result {
+fn shallow_yields_no_result_if_provided_refs_are_in_truncated_part_of_history() -> Result<(), gix_error::Error> {
     run_test(
         |_| odb_at("shallow-1-clone"),
         |_| describe::Options {
@@ -223,7 +226,7 @@ fn shallow_yields_no_result_if_provided_refs_are_in_truncated_part_of_history()
 }
 
 #[test]
-fn shallow_yields_result_if_refs_are_available() -> crate::Result {
+fn shallow_yields_result_if_refs_are_available() -> Result<(), gix_error::Error> {
     let name = Cow::Borrowed(b"at-c5".as_bstr());
     run_test(
         |_| odb_at("shallow-2-clone"),
diff --git a/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs b/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
index dae8a7a100c..5292dfffdcd 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/at_symbol.rs
@@ -1,12 +1,13 @@
-use gix_revision::spec;
-
 use crate::spec::parse::{parse, try_parse};
 
 #[test]
 fn braces_must_be_closed() {
     for unclosed_spec in ["@{something", "@{", "@{..@"] {
         let err = try_parse(unclosed_spec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnclosedBracePair {input} if input == unclosed_spec[1..]));
+        assert_eq!(
+            err.input.as_ref().map(std::convert::AsRef::as_ref),
+            Some(&unclosed_spec.as_bytes()[1..])
+        );
     }
 }
 
@@ -75,7 +76,7 @@ fn reflog_by_unix_timestamp_for_current_branch() {
 #[test]
 fn reflog_by_date_with_date_parse_failure() {
     let err = try_parse("@{foo}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::Time {input, source} if input == "foo" && source.is_some()));
+    insta::assert_snapshot!(err, @"could not parse time for reflog lookup: foo");
 }
 
 #[test]
@@ -86,7 +87,8 @@ fn reflog_by_date_for_hash_is_invalid() {
         ("v1.2.3-0-g1234@{42 +0030}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::ReflogLookupNeedsRefName {name} if name == full_name));
+        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
+        assert!(err.message.contains("reflog entries require a ref name"));
     }
 }
 
@@ -132,7 +134,8 @@ fn reflog_by_entry_for_hash_is_invalid() {
         ("v1.2.3-0-g1234@{2}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::ReflogLookupNeedsRefName {name} if name == full_name));
+        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
+        assert!(err.message.contains("reflog entries require a ref name"));
     }
 }
 
@@ -178,17 +181,16 @@ fn sibling_branch_for_hash_is_invalid() {
         ("v1.2.3-0-g1234@{upstream}", "v1.2.3-0-g1234"),
     ] {
         let err = try_parse(spec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::SiblingBranchNeedsBranchName {name} if name == full_name));
+        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(full_name.as_bytes()));
+        assert!(err.message.contains("sibling branches"));
     }
 }
 
 #[test]
 fn nth_checked_out_branch_for_refname_is_invalid() {
     let err = try_parse("r1@{-1}").unwrap_err();
-    assert!(
-        matches!(err, spec::parse::Error::RefnameNeedsPositiveReflogEntries {nav} if nav == "-1"),
-        "its undefined how to handle negative numbers and specified ref names"
-    );
+    // its undefined how to handle negative numbers and specified ref names
+    insta::assert_snapshot!(err, @"reference name must be followed by positive numbers in @{n}: -1");
 }
 
 #[test]
@@ -210,10 +212,8 @@ fn nth_checked_out_branch() {
 #[test]
 fn numbers_within_braces_cannot_be_negative_zero() {
     let err = try_parse("@{-0}").unwrap_err();
-    assert!(
-        matches!(err, spec::parse::Error::NegativeZero {input} if input == "-0"),
-        "negative zero is not accepted, even though it could easily be defaulted to 0 which is a valid value"
-    );
+    // negative zero is not accepted, even though it could easily be defaulted to 0 which is a valid value
+    insta::assert_snapshot!(err, @"negative zero is invalid - remove the minus sign: -0");
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs b/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
index a4fd29ef673..9c1ed758262 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/colon_symbol.rs
@@ -1,5 +1,3 @@
-use gix_revision::spec;
-
 use crate::spec::parse::{parse, try_parse};
 
 #[test]
@@ -104,25 +102,22 @@ fn various_valid_index_lookups_by_path_and_stage() {
 #[test]
 fn empty_top_level_regex_are_invalid() {
     let err = try_parse(":/").unwrap_err();
-    assert!(
-        matches!(err, spec::parse::Error::EmptyTopLevelRegex),
-        "git also can't do it, finds nothing instead. It could be the youngest commit in theory, but isn't"
-    );
+    // git also can't do it, finds nothing instead. It could be the youngest commit in theory, but isn't
+    insta::assert_snapshot!(err, @"':/' must be followed by a regular expression");
 }
 
 #[test]
 fn regex_with_empty_exclamation_mark_prefix_is_invalid() {
     let err = try_parse(r#":/!hello"#).unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnspecifiedRegexModifier {regex} if regex == "!hello"));
+    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"!hello".as_ref()));
+    insta::assert_snapshot!(err, @"need one character after /!, typically -: !hello");
 }
 
 #[test]
 fn needs_suffix() {
     let err = try_parse(":").unwrap_err();
-    assert!(
-        matches!(err, spec::parse::Error::MissingColonSuffix),
-        "git also can't do it, finds nothing instead. It could be the youngest commit in theory, but isn't"
-    );
+    // git also can't do it, finds nothing instead. It could be the youngest commit in theory, but isn't
+    insta::assert_snapshot!(err, @"':' must be followed by either slash and regex or path to lookup in HEAD tree");
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/anchor/refnames.rs b/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
index 981a3bdb82b..4fd52c0e9ce 100644
--- a/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
+++ b/gix-revision/tests/revision/spec/parse/anchor/refnames.rs
@@ -35,10 +35,7 @@ fn at_in_ranges_is_allowed() {
 #[test]
 fn strange_revspecs_do_not_panic() {
     let err = try_parse(".@.").unwrap_err();
-    assert!(matches!(
-        err,
-        gix_revision::spec::parse::Error::AtNeedsCurlyBrackets { input } if input == "@."
-    ));
+    insta::assert_snapshot!(err, @"@ character must be standalone or followed by {<content>}: @.");
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/kind.rs b/gix-revision/tests/revision/spec/parse/kind.rs
index 78315c594a9..c50668d9cc2 100644
--- a/gix-revision/tests/revision/spec/parse/kind.rs
+++ b/gix-revision/tests/revision/spec/parse/kind.rs
@@ -1,12 +1,10 @@
-use gix_revision::spec;
-
 use crate::spec::parse::{try_parse, try_parse_opts, Options};
 
 #[test]
 fn cannot_declare_ranges_multiple_times() {
     for invalid_spec in ["^HEAD..", "^HEAD..."] {
-        let err = try_parse(invalid_spec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::KindSetTwice { .. }));
+        let err = try_parse(invalid_spec).unwrap_err().into_box();
+        assert!(err.message.contains("cannot set spec kind more than once"));
     }
 }
 
@@ -19,11 +17,10 @@ fn delegate_can_refuse_spec_kinds() {
             ..Default::default()
         },
     )
-    .unwrap_err();
-    assert!(
-        matches!(err, spec::parse::Error::Delegate),
-        "Delegates can refuse spec kind changes to abort parsing early in case they want single-specs only"
-    );
+    .unwrap_err()
+    .into_box();
+    // Delegates can refuse spec kind changes to abort parsing early in case they want single-specs only
+    insta::assert_snapshot!(err, @"delegate.kind(ExcludeReachable) failed");
 }
 
 mod include_parents {
@@ -56,8 +53,8 @@ mod include_parents {
 
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
-        let err = try_parse("r1^@~1").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^@~1").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 }
 
@@ -101,8 +98,8 @@ mod exclude_parents {
 
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
-        let err = try_parse("r1^!~1").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^!~1").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 }
 
@@ -230,26 +227,26 @@ mod range {
 
     #[test]
     fn minus_with_n_omitted_has_to_end_there() {
-        let err = try_parse("r1^-^").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^-^").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_has_to_end_there() {
-        let err = try_parse("r1^-42^").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^-42^").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_has_to_end_there_and_handle_range_suffix() {
-        let err = try_parse("r1^-42..").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^-42..").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_omitted_has_to_end_there_and_handle_range_suffix() {
-        let err = try_parse("r1^-..").unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput { .. }));
+        let err = try_parse("r1^-..").unwrap_err().into_box();
+        assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
diff --git a/gix-revision/tests/revision/spec/parse/mod.rs b/gix-revision/tests/revision/spec/parse/mod.rs
index db0c352c345..4abf877d9c4 100644
--- a/gix-revision/tests/revision/spec/parse/mod.rs
+++ b/gix-revision/tests/revision/spec/parse/mod.rs
@@ -1,3 +1,4 @@
+use gix_error::{bail, message, ErrorExt, Exn};
 use gix_object::bstr::{BStr, BString};
 use gix_revision::{
     spec,
@@ -82,26 +83,30 @@ impl Recorder {
     }
 }
 
-fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T) -> Option<()> {
+fn set_val<T: std::fmt::Debug>(fn_name: &str, store: &mut [Option<T>; 2], val: T) -> Result<(), Exn> {
     for entry in store.iter_mut() {
         if entry.is_none() {
             *entry = Some(val);
-            return Some(());
+            return Ok(());
         }
     }
     panic!("called {fn_name}() more than twice with '{val:?}'");
 }
 
 impl delegate::Revision for Recorder {
-    fn find_ref(&mut self, input: &BStr) -> Option<()> {
+    fn find_ref(&mut self, input: &BStr) -> Result<(), Exn> {
         self.called(Call::FindRef);
         set_val("find_ref", &mut self.find_ref, input.into())
     }
 
-    fn disambiguate_prefix(&mut self, input: gix_hash::Prefix, hint: Option<delegate::PrefixHint<'_>>) -> Option<()> {
+    fn disambiguate_prefix(
+        &mut self,
+        input: gix_hash::Prefix,
+        hint: Option<delegate::PrefixHint<'_>>,
+    ) -> Result<(), Exn> {
         self.called(Call::DisambiguatePrefix);
         if self.opts.reject_prefix {
-            return None;
+            bail!(message!("disambiguate_prefix rejected").erased());
         }
         set_val("disambiguate_prefix", &mut self.prefix, input)?;
         if let Some(hint) = hint {
@@ -117,10 +122,10 @@ impl delegate::Revision for Recorder {
                 },
             )?;
         }
-        Some(())
+        Ok(())
     }
 
-    fn reflog(&mut self, entry: delegate::ReflogLookup) -> Option<()> {
+    fn reflog(&mut self, entry: delegate::ReflogLookup) -> Result<(), Exn> {
         self.called(Call::Reflog);
         set_val(
             "current_branch_reflog",
@@ -136,26 +141,26 @@ impl delegate::Revision for Recorder {
         )
     }
 
-    fn nth_checked_out_branch(&mut self, branch: usize) -> Option<()> {
+    fn nth_checked_out_branch(&mut self, branch: usize) -> Result<(), Exn> {
         assert_ne!(branch, 0);
         self.called(Call::NthCheckedOutBranch);
         set_val("nth_checked_out_branch", &mut self.nth_checked_out_branch, branch)
     }
 
-    fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Option<()> {
+    fn sibling_branch(&mut self, kind: delegate::SiblingBranch) -> Result<(), Exn> {
         self.called(Call::SiblingBranch);
         set_val("sibling_branch", &mut self.sibling_branch, format!("{kind:?}"))
     }
 }
 
 impl delegate::Navigate for Recorder {
-    fn traverse(&mut self, kind: delegate::Traversal) -> Option<()> {
+    fn traverse(&mut self, kind: delegate::Traversal) -> Result<(), Exn> {
         self.called(Call::Traverse);
         self.traversal.push(kind);
-        Some(())
+        Ok(())
     }
 
-    fn peel_until(&mut self, kind: delegate::PeelTo) -> Option<()> {
+    fn peel_until(&mut self, kind: delegate::PeelTo) -> Result<(), Exn> {
         self.called(Call::PeelUntil);
         self.peel_to.push(match kind {
             delegate::PeelTo::ObjectKind(kind) => PeelToOwned::ObjectKind(kind),
@@ -163,40 +168,41 @@ impl delegate::Navigate for Recorder {
             delegate::PeelTo::Path(path) => PeelToOwned::Path(path.into()),
             delegate::PeelTo::RecursiveTagObject => PeelToOwned::RecursiveTagObject,
         });
-        Some(())
+        Ok(())
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Option<()> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
         self.called(Call::Find);
         self.patterns.push((regex.into(), negated));
-        Some(())
+        Ok(())
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
         self.called(Call::IndexLookup);
         self.index_lookups.push((path.into(), stage));
-        Some(())
+        Ok(())
     }
 }
 
 impl delegate::Kind for Recorder {
-    fn kind(&mut self, kind: spec::Kind) -> Option<()> {
+    fn kind(&mut self, kind: spec::Kind) -> Result<(), Exn> {
         self.called(Call::Kind);
         if self.opts.reject_kind {
-            return None;
+            bail!(message!("kind() was rejected").erased());
         }
         if self.kind.is_none() {
             self.kind = Some(kind);
         } else if !self.opts.no_internal_assertions {
             panic!("called kind more than once with '{kind:?}'");
         }
-        Some(())
+        Ok(())
     }
 }
 
 impl Delegate for Recorder {
-    fn done(&mut self) {
+    fn done(&mut self) -> Result<(), Exn> {
         self.done = true;
+        Ok(())
     }
 }
 
@@ -204,11 +210,11 @@ fn parse(spec: &str) -> Recorder {
     try_parse_opts(spec, Options::default()).unwrap()
 }
 
-fn try_parse(spec: &str) -> Result<Recorder, spec::parse::Error> {
+fn try_parse(spec: &str) -> Result<Recorder, Exn<spec::parse::Error>> {
     try_parse_opts(spec, Default::default())
 }
 
-fn try_parse_opts(spec: &str, options: Options) -> Result<Recorder, spec::parse::Error> {
+fn try_parse_opts(spec: &str, options: Options) -> Result<Recorder, Exn<spec::parse::Error>> {
     let mut rec = Recorder::with(options);
     spec::parse(spec.into(), &mut rec)?;
     Ok(rec)
diff --git a/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs b/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
index 245f9411604..c314d10cc31 100644
--- a/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
@@ -1,4 +1,4 @@
-use gix_revision::{spec, spec::parse::delegate::Traversal};
+use gix_revision::spec::parse::delegate::Traversal;
 
 use crate::spec::parse::{parse, try_parse, PeelToOwned as PeelTo};
 
@@ -57,8 +57,9 @@ fn followed_by_zero_is_peeling_to_commit() {
 
 #[test]
 fn explicitly_positive_numbers_are_invalid() {
-    let err = try_parse("@^+1").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::SignedNumber {input} if input == "+1"));
+    let err = try_parse("@^+1").unwrap_err().into_box();
+    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"+1".as_ref()));
+    assert!(err.message.contains("positive numbers are invalid"));
 }
 
 #[test]
@@ -180,12 +181,13 @@ fn empty_braces_deref_a_tag() {
 
 #[test]
 fn invalid_object_type() {
-    let err = try_parse("@^{invalid}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::InvalidObject {input} if input == "invalid"));
+    let err = try_parse("@^{invalid}").unwrap_err().into_box();
+    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"invalid".as_ref()));
+    assert!(err.message.contains("cannot peel"));
 
-    let err = try_parse("@^{Commit}").unwrap_err();
+    let err = try_parse("@^{Commit}").unwrap_err().into_box();
     assert!(
-        matches!(err, spec::parse::Error::InvalidObject {input} if input == "Commit"),
+        err.input.as_ref().map(AsRef::as_ref) == Some(b"Commit".as_ref()) && err.message.contains("cannot peel"),
         "these types are case sensitive"
     );
 }
@@ -202,33 +204,41 @@ fn invalid_caret_without_previous_refname() {
     );
 
     for revspec in ["^^^HEAD", "^^HEAD"] {
-        let err = try_parse(revspec).unwrap_err();
-        assert!(matches!(err, spec::parse::Error::UnconsumedInput {input} if input == "HEAD"));
+        let err = try_parse(revspec).unwrap_err().into_box();
+        assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"HEAD".as_ref()));
+        assert!(err.message.contains("unconsumed input"));
     }
 }
 
 #[test]
 fn incomplete_escaped_braces_in_regex_are_invalid() {
-    let err = try_parse(r"@^{/a\{1}}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnconsumedInput {input} if input == "}"));
+    let err = try_parse(r"@^{/a\{1}}").unwrap_err().into_box();
+    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"}".as_ref()));
+    assert!(err.message.contains("unconsumed input"));
 
-    let err = try_parse(r"@^{/a{1\}}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnclosedBracePair {input} if input == r"{/a{1\}}"));
+    let err = try_parse(r"@^{/a{1\}}").unwrap_err().into_box();
+    assert!(
+        err.input.as_ref().map(AsRef::as_ref) == Some(br"{/a{1\}}".as_ref()) && err.message.contains("unclosed brace")
+    );
 }
 
 #[test]
 fn regex_with_empty_exclamation_mark_prefix_is_invalid() {
-    let err = try_parse(r#"@^{/!hello}"#).unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnspecifiedRegexModifier {regex} if regex == "!hello"));
+    let err = try_parse(r#"@^{/!hello}"#).unwrap_err().into_box();
+    assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"!hello".as_ref()));
+    assert!(err.message.contains("need one character after"));
 }
 
 #[test]
 fn bad_escapes_can_cause_brace_mismatch() {
-    let err = try_parse(r"@^{\}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnclosedBracePair {input} if input == r"{\}"));
+    let err = try_parse(r"@^{\}").unwrap_err().into_box();
+    assert!(err.input.as_ref().map(AsRef::as_ref) == Some(br"{\}".as_ref()) && err.message.contains("unclosed brace"));
 
-    let err = try_parse(r"@^{{\}}").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::UnclosedBracePair {input} if input == r"{{\}}"));
+    let err = try_parse(r"@^{{\}}").unwrap_err().into_box();
+    // The raw string r"{{\}}" contains actual backslashes, so the input would be r"{{\}}"
+    assert!(
+        err.input.as_ref().map(AsRef::as_ref) == Some(br"{{\}}".as_ref()) && err.message.contains("unclosed brace")
+    );
 }
 
 #[test]
diff --git a/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs b/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
index ae1ba826cdc..012a64f5397 100644
--- a/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs
@@ -1,11 +1,11 @@
-use gix_revision::{spec, spec::parse::delegate::Traversal};
+use gix_revision::spec::parse::delegate::Traversal;
 
 use crate::spec::parse::{parse, try_parse};
 
 #[test]
 fn without_anchor_is_invalid() {
-    let err = try_parse("~").unwrap_err();
-    assert!(matches!(err, spec::parse::Error::MissingTildeAnchor));
+    let err = try_parse("~").unwrap_err().into_box();
+    assert!(err.message.contains("tilde needs to follow an anchor"));
 }
 
 #[test]
diff --git a/gix/Cargo.toml b/gix/Cargo.toml
index 93b27a511dc..1fad330abb8 100644
--- a/gix/Cargo.toml
+++ b/gix/Cargo.toml
@@ -311,6 +311,7 @@ blame-experimental = ["blame", "gix-blame/blob-experimental"]
 
 
 [dependencies]
+gix-error = { version = "0.0.0", path = "../gix-error" }
 gix-utils = { version = "^0.3.1", path = "../gix-utils" }
 gix-fs = { version = "^0.18.2", path = "../gix-fs" }
 gix-ref = { version = "^0.57.0", path = "../gix-ref" }
diff --git a/gix/src/commit.rs b/gix/src/commit.rs
index f12c5f88631..8ffaef8ef2b 100644
--- a/gix/src/commit.rs
+++ b/gix/src/commit.rs
@@ -33,10 +33,10 @@ impl From<std::convert::Infallible> for Error {
 ///
 #[cfg(feature = "revision")]
 pub mod describe {
-    use std::borrow::Cow;
-
+    use gix_error::Exn;
     use gix_hash::ObjectId;
     use gix_hashtable::HashMap;
+    use std::borrow::Cow;
 
     use crate::{bstr::BStr, ext::ObjectIdExt, Repository};
 
@@ -84,7 +84,7 @@ pub mod describe {
         #[error(transparent)]
         OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
         #[error(transparent)]
-        Describe(#[from] gix_revision::describe::Error),
+        Describe(#[from] Box<gix_revision::describe::Error>),
         #[error("Could not produce an unambiguous shortened id for formatting.")]
         ShortId(#[from] crate::id::shorten::Error),
         #[error(transparent)]
@@ -244,7 +244,8 @@ pub mod describe {
                     first_parent: self.first_parent,
                     max_candidates: self.max_candidates,
                 },
-            )?;
+            )
+            .map_err(Exn::into_box)?;
 
             Ok(outcome.map(|outcome| Resolution {
                 outcome,
diff --git a/gix/src/config/mod.rs b/gix/src/config/mod.rs
index ffcd31edf7b..56b06c314d8 100644
--- a/gix/src/config/mod.rs
+++ b/gix/src/config/mod.rs
@@ -451,7 +451,7 @@ pub mod remote {
 ///
 pub mod time {
     /// The error produced when failing to parse time from configuration.
-    pub type Error = super::key::Error<gix_date::parse::Error, 't', 'i'>;
+    pub type Error = super::key::Error<gix_date::Error, 't', 'i'>;
 }
 
 ///
diff --git a/gix/src/config/tree/keys.rs b/gix/src/config/tree/keys.rs
index c2df5a3842e..d2040cc4b35 100644
--- a/gix/src/config/tree/keys.rs
+++ b/gix/src/config/tree/keys.rs
@@ -409,8 +409,6 @@ mod workers {
 }
 
 mod time {
-    use std::borrow::Cow;
-
     use crate::{
         bstr::{BStr, ByteSlice},
         config::tree::{
@@ -418,6 +416,8 @@ mod time {
             Section,
         },
     };
+    use gix_error::Exn;
+    use std::borrow::Cow;
 
     impl Time {
         /// Create a new instance.
@@ -430,14 +430,11 @@ mod time {
             &self,
             value: Cow<'_, BStr>,
             now: Option<std::time::SystemTime>,
-        ) -> Result<gix_date::Time, gix_date::parse::Error> {
+        ) -> Result<gix_date::Time, Exn<gix_date::Error>> {
             gix_date::parse(
-                value
-                    .as_ref()
-                    .to_str()
-                    .map_err(|_| gix_date::parse::Error::InvalidDateString {
-                        input: value.to_string(),
-                    })?,
+                value.as_ref().to_str().map_err(|_| {
+                    gix_date::Error::new_with_input("UTF8 conversion failed", value.clone().into_owned())
+                })?,
                 now,
             )
         }
@@ -530,7 +527,7 @@ pub mod validate {
 
     impl Validate for Time {
         fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            gix_date::parse(value.to_str()?, std::time::SystemTime::now().into())?;
+            gix_date::parse(value.to_str()?, std::time::SystemTime::now().into()).map_err(gix_error::Exn::into_box)?;
             Ok(())
         }
     }
diff --git a/gix/src/lib.rs b/gix/src/lib.rs
index dae7b7f4b1e..01a61914873 100644
--- a/gix/src/lib.rs
+++ b/gix/src/lib.rs
@@ -105,6 +105,7 @@ pub use gix_credentials as credentials;
 pub use gix_date as date;
 #[cfg(feature = "dirwalk")]
 pub use gix_dir as dir;
+pub use gix_error as error;
 pub use gix_features as features;
 use gix_features::threading::OwnShared;
 pub use gix_features::{
@@ -144,6 +145,8 @@ pub use gix_utils as utils;
 pub use gix_validate as validate;
 pub use hash::{oid, ObjectId};
 
+pub use gix_error::{Error, Exn};
+
 pub mod interrupt;
 
 mod ext;
diff --git a/gix/src/object/commit.rs b/gix/src/object/commit.rs
index a872f02f972..568513a0b17 100644
--- a/gix/src/object/commit.rs
+++ b/gix/src/object/commit.rs
@@ -11,7 +11,7 @@ mod error {
         #[error("The commit could not be decoded fully or partially")]
         Decode(#[from] gix_object::decode::Error),
         #[error("The commit date could not be parsed")]
-        ParseDate(#[from] gix_date::parse::Error),
+        ParseDate(#[from] gix_date::Error),
         #[error("Expected object of type {}, but got {}", .expected, .actual)]
         ObjectKind {
             expected: gix_object::Kind,
diff --git a/gix/src/repository/revision.rs b/gix/src/repository/revision.rs
index 72d677b72f0..f85564e9202 100644
--- a/gix/src/repository/revision.rs
+++ b/gix/src/repository/revision.rs
@@ -12,7 +12,7 @@ impl crate::Repository {
     ///   `HEAD` ref available for lookups.
     #[doc(alias = "revparse", alias = "git2")]
     #[cfg(feature = "revision")]
-    pub fn rev_parse<'a>(&self, spec: impl Into<&'a BStr>) -> Result<revision::Spec<'_>, revision::spec::parse::Error> {
+    pub fn rev_parse<'a>(&self, spec: impl Into<&'a BStr>) -> Result<revision::Spec<'_>, gix_error::Error> {
         revision::Spec::from_bstr(
             spec,
             self,
diff --git a/gix/src/revision/spec/parse/delegate/mod.rs b/gix/src/revision/spec/parse/delegate/mod.rs
index d0c2611a8c7..b452c8bd639 100644
--- a/gix/src/revision/spec/parse/delegate/mod.rs
+++ b/gix/src/revision/spec/parse/delegate/mod.rs
@@ -1,14 +1,12 @@
-use std::collections::HashSet;
-
-use gix_hash::ObjectId;
-use gix_revision::spec::{parse, parse::delegate};
-use smallvec::SmallVec;
-
-use super::{Delegate, Error, ObjectKindHint};
+use super::{error, Delegate, ObjectKindHint};
 use crate::{
     ext::{ObjectIdExt, ReferenceExt},
     Repository,
 };
+use gix_error::{message, ErrorExt, Exn, ResultExt};
+use gix_hash::ObjectId;
+use gix_revision::spec::{parse, parse::delegate};
+use smallvec::SmallVec;
 
 type Replacements = SmallVec<[(ObjectId, ObjectId); 1]>;
 
@@ -21,7 +19,7 @@ impl<'repo> Delegate<'repo> {
             ambiguous_objects: Default::default(),
             idx: 0,
             kind: None,
-            err: Vec::new(),
+            delayed_errors: Vec::new(),
             prefix: Default::default(),
             last_call_was_disambiguate_prefix: Default::default(),
             opts,
@@ -29,28 +27,40 @@ impl<'repo> Delegate<'repo> {
         }
     }
 
-    pub fn into_err(mut self) -> Error {
+    pub fn into_delayed_errors(mut self) -> Option<Exn> {
         let repo = self.repo;
-        for err in self
+        let mut delayed_errors = self.delayed_errors;
+        let mut ambiguous_errors: Vec<_> = self
             .ambiguous_objects
             .iter_mut()
             .zip(self.prefix)
             .filter_map(|(a, b)| a.take().filter(|candidates| candidates.len() > 1).zip(b))
-            .map(|(candidates, prefix)| Error::ambiguous(candidates, prefix, repo))
+            .map(|(candidates, prefix)| error::ambiguous(candidates, prefix, repo))
             .rev()
-        {
-            self.err.insert(0, err);
+            .map(|err| err.erased())
+            .collect();
+
+        match (ambiguous_errors.pop(), ambiguous_errors.pop()) {
+            (Some(one), None) => Some(one),
+            (Some(one), Some(two)) => {
+                Some(Exn::from_iter([one, two], message!("Both objects were ambiguous")).erased())
+            }
+            _ => (!delayed_errors.is_empty()).then(|| {
+                if delayed_errors.len() == 1 {
+                    delayed_errors.pop().expect("it's exactly one")
+                } else {
+                    Exn::from_iter(delayed_errors, message!("one or more delayed errors")).erased()
+                }
+            }),
         }
-        Error::from_errors(self.err)
     }
 
-    pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>, Error> {
+    pub fn into_rev_spec(mut self) -> Result<crate::revision::Spec<'repo>, gix_error::Error> {
         fn zero_or_one_objects_or_ambiguity_err(
-            mut candidates: [Option<HashSet<ObjectId>>; 2],
+            mut candidates: [Option<Vec<ObjectId>>; 2],
             prefix: [Option<gix_hash::Prefix>; 2],
-            mut errors: Vec<Error>,
             repo: &Repository,
-        ) -> Result<[Option<ObjectId>; 2], Error> {
+        ) -> Result<[Option<ObjectId>; 2], gix_error::Error> {
             let mut out = [None, None];
             for ((candidates, prefix), out) in candidates.iter_mut().zip(prefix).zip(out.iter_mut()) {
                 let candidates = candidates.take();
@@ -64,11 +74,10 @@ impl<'repo> Delegate<'repo> {
                             *out = candidates.into_iter().next();
                         }
                         _ => {
-                            errors.insert(
-                                0,
-                                Error::ambiguous(candidates, prefix.expect("set when obtaining candidates"), repo),
-                            );
-                            return Err(Error::from_errors(errors));
+                            let err =
+                                error::ambiguous(candidates, prefix.expect("set when obtaining candidates"), repo)
+                                    .erased();
+                            return Err(err.into_error());
                         }
                     },
                 }
@@ -79,25 +88,30 @@ impl<'repo> Delegate<'repo> {
         fn kind_to_spec(
             kind: Option<gix_revision::spec::Kind>,
             [first, second]: [Option<ObjectId>; 2],
-        ) -> Result<gix_revision::Spec, Error> {
+        ) -> Result<gix_revision::Spec, gix_error::Error> {
+            pub fn malformed() -> gix_error::Error {
+                message!("The rev-spec is malformed and misses a ref name")
+                    .raise()
+                    .into_error()
+            }
             use gix_revision::spec::Kind::*;
             Ok(match kind.unwrap_or_default() {
-                IncludeReachable => gix_revision::Spec::Include(first.ok_or(Error::Malformed)?),
-                ExcludeReachable => gix_revision::Spec::Exclude(first.ok_or(Error::Malformed)?),
+                IncludeReachable => gix_revision::Spec::Include(first.ok_or_else(malformed)?),
+                ExcludeReachable => gix_revision::Spec::Exclude(first.ok_or_else(malformed)?),
                 RangeBetween => gix_revision::Spec::Range {
-                    from: first.ok_or(Error::Malformed)?,
-                    to: second.ok_or(Error::Malformed)?,
+                    from: first.ok_or_else(malformed)?,
+                    to: second.ok_or_else(malformed)?,
                 },
                 ReachableToMergeBase => gix_revision::Spec::Merge {
-                    theirs: first.ok_or(Error::Malformed)?,
-                    ours: second.ok_or(Error::Malformed)?,
+                    theirs: first.ok_or_else(malformed)?,
+                    ours: second.ok_or_else(malformed)?,
                 },
-                IncludeReachableFromParents => gix_revision::Spec::IncludeOnlyParents(first.ok_or(Error::Malformed)?),
-                ExcludeReachableFromParents => gix_revision::Spec::ExcludeParents(first.ok_or(Error::Malformed)?),
+                IncludeReachableFromParents => gix_revision::Spec::IncludeOnlyParents(first.ok_or_else(malformed)?),
+                ExcludeReachableFromParents => gix_revision::Spec::ExcludeParents(first.ok_or_else(malformed)?),
             })
         }
 
-        let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.err, self.repo)?;
+        let range = zero_or_one_objects_or_ambiguity_err(self.objs, self.prefix, self.repo)?;
         Ok(crate::revision::Spec {
             path: self.paths[0].take().or(self.paths[1].take()),
             first_ref: self.refs[0].take(),
@@ -109,47 +123,55 @@ impl<'repo> Delegate<'repo> {
 }
 
 impl parse::Delegate for Delegate<'_> {
-    fn done(&mut self) {
-        self.follow_refs_to_objects_if_needed();
-        self.disambiguate_objects_by_fallback_hint(
+    fn done(&mut self) -> Result<(), Exn> {
+        self.follow_refs_to_objects_if_needed_delay_errors();
+        self.disambiguate_objects_by_fallback_hint_delay_errors(
             self.kind_implies_committish()
                 .then_some(ObjectKindHint::Committish)
                 .or(self.opts.object_kind_hint),
         );
+        // Never fail, let it be handled by the spec conversion.
+        Ok(())
     }
 }
 
 impl delegate::Kind for Delegate<'_> {
-    fn kind(&mut self, kind: gix_revision::spec::Kind) -> Option<()> {
+    fn kind(&mut self, kind: gix_revision::spec::Kind) -> Result<(), Exn> {
         use gix_revision::spec::Kind::*;
         self.kind = Some(kind);
 
         if self.kind_implies_committish() {
-            self.disambiguate_objects_by_fallback_hint(ObjectKindHint::Committish.into());
+            self.disambiguate_objects_by_fallback_hint_delay_errors(ObjectKindHint::Committish.into());
         }
         if matches!(kind, RangeBetween | ReachableToMergeBase) {
             self.idx += 1;
         }
 
-        Some(())
+        Ok(())
     }
 }
 
 impl Delegate<'_> {
+    fn has_delayed_err(&self) -> bool {
+        !self.delayed_errors.is_empty()
+    }
     fn kind_implies_committish(&self) -> bool {
         self.kind.unwrap_or(gix_revision::spec::Kind::IncludeReachable) != gix_revision::spec::Kind::IncludeReachable
     }
-    fn disambiguate_objects_by_fallback_hint(&mut self, hint: Option<ObjectKindHint>) {
-        fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<(), Error> {
-            let obj = repo.find_object(obj)?;
+
+    fn disambiguate_objects_by_fallback_hint_delay_errors(&mut self, hint: Option<ObjectKindHint>) {
+        fn require_object_kind(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<(), Exn> {
+            let obj = repo.find_object(obj).or_erased()?;
             if obj.kind == kind {
                 Ok(())
             } else {
-                Err(Error::ObjectKind {
-                    actual: obj.kind,
-                    expected: kind,
-                    oid: obj.id.attach(repo).shorten_or_id(),
-                })
+                Err(message!(
+                    "Object {oid} was a {actual}, but needed it to be a {expected}",
+                    actual = obj.kind,
+                    expected = kind,
+                    oid = obj.id.attach(repo).shorten_or_id(),
+                )
+                .erased())
             }
         }
 
@@ -185,38 +207,48 @@ impl Delegate<'_> {
                     None => return,
                 };
 
-                if errors.len() == objs.len() {
-                    self.err.extend(errors.into_iter().map(|(_, err)| err));
+                let disambiguation_failed = errors.len() == objs.len();
+                if disambiguation_failed {
+                    self.delayed_errors.extend(errors.into_iter().map(|(_, err)| err));
                 } else {
-                    for (obj, err) in errors {
-                        objs.remove(&obj);
-                        self.err.push(err);
+                    for (ambiguous_obj, err) in errors {
+                        if let Some(pos) = objs.iter().position(|obj| obj == &ambiguous_obj) {
+                            objs.remove(pos);
+                        }
+                        self.delayed_errors.push(err);
                     }
                 }
             }
         }
     }
-    fn follow_refs_to_objects_if_needed(&mut self) -> Option<()> {
+
+    fn follow_refs_to_objects_if_needed_delay_errors(&mut self) {
         let repo = self.repo;
         for (r, obj) in self.refs.iter().zip(self.objs.iter_mut()) {
             if let (Some(ref_), obj_opt @ None) = (r, obj) {
                 if let Some(id) = ref_.target.try_id().map(ToOwned::to_owned).or_else(|| {
                     match ref_.clone().attach(repo).peel_to_id() {
                         Err(err) => {
-                            self.err.push(Error::PeelToId {
-                                name: ref_.name.clone(),
-                                source: err,
-                            });
+                            self.delayed_errors.push(
+                                err.raise()
+                                    .raise(message!(
+                                        "Could not peel '{}' to obtain its target",
+                                        ref_.name.as_bstr()
+                                    ))
+                                    .erased(),
+                            );
                             None
                         }
                         Ok(id) => Some(id.detach()),
                     }
                 }) {
-                    obj_opt.get_or_insert_with(HashSet::default).insert(id);
+                    let objs = obj_opt.get_or_insert_with(Vec::new);
+                    if !objs.contains(&id) {
+                        objs.push(id);
+                    }
                 }
             }
         }
-        Some(())
     }
 
     fn unset_disambiguate_call(&mut self) {
@@ -224,34 +256,12 @@ impl Delegate<'_> {
     }
 }
 
-fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<ObjectId, Error> {
-    let mut obj = repo.find_object(obj)?;
-    obj = obj.peel_to_kind(kind)?;
+fn peel(repo: &Repository, obj: &gix_hash::oid, kind: gix_object::Kind) -> Result<ObjectId, Exn> {
+    let mut obj = repo.find_object(obj).or_erased()?;
+    obj = obj.peel_to_kind(kind).or_erased()?;
     debug_assert_eq!(obj.kind, kind, "bug in Object::peel_to_kind() which didn't deliver");
     Ok(obj.id)
 }
 
-fn handle_errors_and_replacements(
-    destination: &mut Vec<Error>,
-    objs: &mut HashSet<ObjectId>,
-    errors: Vec<(ObjectId, Error)>,
-    replacements: &mut Replacements,
-) -> Option<()> {
-    if errors.len() == objs.len() {
-        destination.extend(errors.into_iter().map(|(_, err)| err));
-        None
-    } else {
-        for (obj, err) in errors {
-            objs.remove(&obj);
-            destination.push(err);
-        }
-        for (find, replace) in replacements {
-            objs.remove(find);
-            objs.insert(*replace);
-        }
-        Some(())
-    }
-}
-
 mod navigate;
 mod revision;
diff --git a/gix/src/revision/spec/parse/delegate/navigate.rs b/gix/src/revision/spec/parse/delegate/navigate.rs
index ca32061acd7..5ed684dd2c9 100644
--- a/gix/src/revision/spec/parse/delegate/navigate.rs
+++ b/gix/src/revision/spec/parse/delegate/navigate.rs
@@ -1,5 +1,4 @@
-use std::collections::HashSet;
-
+use gix_error::{bail, message, ErrorExt, Exn, OptionExt, ResultExt};
 use gix_hash::ObjectId;
 use gix_index::entry::Stage;
 use gix_revision::spec::parse::{
@@ -7,29 +6,26 @@ use gix_revision::spec::parse::{
     delegate::{PeelTo, Traversal},
 };
 
+use crate::revision::spec::parse::delegate::peel;
 use crate::{
     bstr::{BStr, ByteSlice},
     ext::ObjectIdExt,
     object,
-    revision::spec::parse::{
-        delegate::{handle_errors_and_replacements, peel, Replacements},
-        Delegate, Error,
-    },
+    revision::spec::parse::{delegate::Replacements, Delegate},
     Object,
 };
 
 impl delegate::Navigate for Delegate<'_> {
-    fn traverse(&mut self, kind: Traversal) -> Option<()> {
+    fn traverse(&mut self, kind: Traversal) -> Result<(), Exn> {
         self.unset_disambiguate_call();
-        self.follow_refs_to_objects_if_needed()?;
+        self.follow_refs_to_objects_if_needed_delay_errors();
 
         let mut replacements = Replacements::default();
-        let mut errors = Vec::new();
+        let mut errors = Vec::<(ObjectId, Exn)>::new();
         let objs = match self.objs[self.idx].as_mut() {
             Some(objs) => objs,
             None => {
-                self.err.push(Error::TraversalWithoutStartObject);
-                return None;
+                bail!(message!("Tried to navigate the commit-graph without providing an anchor first").erased())
             }
         };
         let repo = self.repo;
@@ -37,25 +33,27 @@ impl delegate::Navigate for Delegate<'_> {
         for obj in objs.iter() {
             match kind {
                 Traversal::NthParent(num) => {
-                    match self.repo.find_object(*obj).map_err(Error::from).and_then(|obj| {
+                    match self.repo.find_object(*obj).or_erased().and_then(|obj| {
                         obj.try_into_commit().map_err(|err| {
                             let object::try_into::Error { actual, expected, id } = err;
-                            Error::ObjectKind {
-                                oid: id.attach(repo).shorten_or_id(),
-                                actual,
-                                expected,
-                            }
+                            message!(
+                                "Object {oid} was a {actual}, but needed it to be a {expected}",
+                                oid = id.attach(repo).shorten_or_id(),
+                            )
+                            .erased()
                         })
                     }) {
                         Ok(commit) => match commit.parent_ids().nth(num.saturating_sub(1)) {
                             Some(id) => replacements.push((commit.id, id.detach())),
                             None => errors.push((
                                 commit.id,
-                                Error::ParentOutOfRange {
-                                    oid: commit.id().shorten_or_id(),
-                                    desired: num,
-                                    available: commit.parent_ids().count(),
-                                },
+                                message!(
+                                    "Commit {oid} has {available} parents and parent number {desired} is out of range",
+                                    oid = commit.id().shorten_or_id(),
+                                    desired = num,
+                                    available = commit.parent_ids().count(),
+                                )
+                                .erased(),
                             )),
                         },
                         Err(err) => errors.push((*obj, err)),
@@ -74,44 +72,42 @@ impl delegate::Navigate for Delegate<'_> {
                         Some(commit) => replacements.push((*obj, commit.id)),
                         None => errors.push((
                             *obj,
-                            Error::AncestorOutOfRange {
-                                oid: id.shorten_or_id(),
-                                desired: num,
-                                available: id
-                                    .ancestors()
-                                    .first_parent_only()
-                                    .all()
-                                    .expect("cannot fail without sorting")
-                                    .skip(1)
-                                    .count(),
-                            },
+                                message!("Commit {oid} has {available} ancestors along the first parent and ancestor number {num} is out of range",
+                                    oid = id.shorten_or_id(),
+                                    available = id
+                                        .ancestors()
+                                        .first_parent_only()
+                                        .all()
+                                        .expect("cannot fail without sorting")
+                                        .skip(1)
+                                        .count()
+                                ).erased()
                         )),
                     }
                 }
             }
         }
 
-        handle_errors_and_replacements(&mut self.err, objs, errors, &mut replacements)
+        handle_errors_and_replacements(&mut self.delayed_errors, objs, errors, &mut replacements)
     }
 
-    fn peel_until(&mut self, kind: PeelTo<'_>) -> Option<()> {
+    fn peel_until(&mut self, kind: PeelTo<'_>) -> Result<(), Exn> {
         self.unset_disambiguate_call();
-        self.follow_refs_to_objects_if_needed()?;
+        self.follow_refs_to_objects_if_needed_delay_errors();
 
         let mut replacements = Replacements::default();
-        let mut errors = Vec::new();
-        let objs = self.objs[self.idx].as_mut()?;
+        let mut errors = Vec::<(ObjectId, Exn)>::new();
+        let objs = self.objs[self.idx]
+            .as_mut()
+            .ok_or_raise_erased(|| message!("Couldn't get object at internal index {idx}", idx = self.idx))?;
         let repo = self.repo;
 
         match kind {
             PeelTo::ValidObject => {
                 for obj in objs.iter() {
-                    match repo.find_object(*obj) {
-                        Ok(_) => {}
-                        Err(err) => {
-                            errors.push((*obj, err.into()));
-                        }
-                    };
+                    if let Err(err) = repo.find_object(*obj) {
+                        errors.push((*obj, err.erased()));
+                    }
                 }
             }
             PeelTo::ObjectKind(kind) => {
@@ -127,16 +123,20 @@ impl delegate::Navigate for Delegate<'_> {
                 let lookup_path = |obj: &ObjectId| {
                     let tree_id = peel(repo, obj, gix_object::Kind::Tree)?;
                     if path.is_empty() {
-                        return Ok((tree_id, gix_object::tree::EntryKind::Tree.into()));
+                        return Ok::<_, Exn>((tree_id, gix_object::tree::EntryKind::Tree.into()));
                     }
-                    let mut tree = repo.find_object(tree_id)?.into_tree();
-                    let entry =
-                        tree.peel_to_entry_by_path(gix_path::from_bstr(path))?
-                            .ok_or_else(|| Error::PathNotFound {
-                                path: path.into(),
-                                object: obj.attach(repo).shorten_or_id(),
-                                tree: tree_id.attach(repo).shorten_or_id(),
-                            })?;
+                    let mut tree = repo.find_object(tree_id).or_erased()?.into_tree();
+                    let entry = tree
+                        .peel_to_entry_by_path(gix_path::from_bstr(path))
+                        .or_erased()?
+                        .ok_or_raise_erased(|| {
+                            message!(
+                                "Could not find path {path:?} in tree {tree} of parent object {object}",
+                                path = path,
+                                object = obj.attach(repo).shorten_or_id(),
+                                tree = tree_id.attach(repo).shorten_or_id(),
+                            )
+                        })?;
                     Ok((entry.object_id(), entry.mode()))
                 };
                 for obj in objs.iter() {
@@ -156,18 +156,18 @@ impl delegate::Navigate for Delegate<'_> {
                 for oid in objs.iter() {
                     match oid.attach(repo).object().and_then(Object::peel_tags_to_end) {
                         Ok(obj) => replacements.push((*oid, obj.id)),
-                        Err(err) => errors.push((*oid, err.into())),
+                        Err(err) => errors.push((*oid, err.erased())),
                     }
                 }
             }
         }
 
-        handle_errors_and_replacements(&mut self.err, objs, errors, &mut replacements)
+        handle_errors_and_replacements(&mut self.delayed_errors, objs, errors, &mut replacements)
     }
 
-    fn find(&mut self, regex: &BStr, negated: bool) -> Option<()> {
+    fn find(&mut self, regex: &BStr, negated: bool) -> Result<(), Exn> {
         self.unset_disambiguate_call();
-        self.follow_refs_to_objects_if_needed()?;
+        self.follow_refs_to_objects_if_needed_delay_errors();
 
         #[cfg(not(feature = "revparse-regex"))]
         let matches = |message: &BStr| -> bool { message.contains_str(regex) ^ negated };
@@ -184,15 +184,14 @@ impl delegate::Navigate for Delegate<'_> {
                 }
             }
             Err(err) => {
-                self.err.push(err.into());
-                return None;
+                bail!(err.erased());
             }
         };
 
         match self.objs[self.idx].as_mut() {
             Some(objs) => {
                 let repo = self.repo;
-                let mut errors = Vec::new();
+                let mut errors = Vec::<(ObjectId, Exn)>::new();
                 let mut replacements = Replacements::default();
                 for oid in objs.iter() {
                     match oid
@@ -205,8 +204,12 @@ impl delegate::Navigate for Delegate<'_> {
                             let mut matched = false;
                             let mut count = 0;
                             let commits = iter.map(|res| {
-                                res.map_err(Error::from).and_then(|commit| {
-                                    commit.id().object().map_err(Error::from).map(Object::into_commit)
+                                res.map_err(|err| err.erased()).and_then(|commit| {
+                                    commit
+                                        .id()
+                                        .object()
+                                        .map_err(|err| err.erased())
+                                        .map(Object::into_commit)
                                 })
                             });
                             for commit in commits {
@@ -225,88 +228,89 @@ impl delegate::Navigate for Delegate<'_> {
                             if !matched {
                                 errors.push((
                                     *oid,
-                                    Error::NoRegexMatch {
-                                        regex: regex.into(),
-                                        commits_searched: count,
-                                        oid: oid.attach(repo).shorten_or_id(),
-                                    },
+                                    message!(
+                                        "None of {commits_searched} commits from {oid} matched {kind} {regex:?}",
+                                        regex = regex,
+                                        commits_searched = count,
+                                        oid = oid.attach(repo).shorten_or_id(),
+                                        kind = if cfg!(feature = "revparse-regex") {
+                                            "regex"
+                                        } else {
+                                            "text"
+                                        }
+                                    )
+                                    .erased(),
                                 ));
                             }
                         }
-                        Err(err) => errors.push((*oid, err.into())),
+                        Err(err) => errors.push((*oid, err.erased())),
                     }
                 }
-                handle_errors_and_replacements(&mut self.err, objs, errors, &mut replacements)
+                handle_errors_and_replacements(&mut self.delayed_errors, objs, errors, &mut replacements)
             }
-            None => match self.repo.references() {
-                Ok(references) => match references.all() {
-                    Ok(references) => {
-                        match self
-                            .repo
-                            .rev_walk(
-                                references
-                                    .peeled()
-                                    .ok()?
-                                    .filter_map(Result::ok)
-                                    .filter(|r| r.id().header().ok().is_some_and(|obj| obj.kind().is_commit()))
-                                    .filter_map(|r| r.detach().peeled),
-                            )
-                            .sorting(crate::revision::walk::Sorting::ByCommitTime(Default::default()))
-                            .all()
-                        {
-                            Ok(iter) => {
-                                let mut matched = false;
-                                let mut count = 0;
-                                let commits = iter.map(|res| {
-                                    res.map_err(Error::from).and_then(|commit| {
-                                        commit.id().object().map_err(Error::from).map(Object::into_commit)
-                                    })
-                                });
-                                for commit in commits {
-                                    count += 1;
-                                    match commit {
-                                        Ok(commit) => {
-                                            if matches(commit.message_raw_sloppy()) {
-                                                self.objs[self.idx]
-                                                    .get_or_insert_with(HashSet::default)
-                                                    .insert(commit.id);
-                                                matched = true;
-                                                break;
-                                            }
-                                        }
-                                        Err(err) => self.err.push(err),
-                                    }
-                                }
-                                if matched {
-                                    Some(())
-                                } else {
-                                    self.err.push(Error::NoRegexMatchAllRefs {
-                                        regex: regex.into(),
-                                        commits_searched: count,
-                                    });
-                                    None
+            None => {
+                let references = self.repo.references().or_erased()?;
+                let references = references.all().or_erased()?;
+                let iter = self
+                    .repo
+                    .rev_walk(
+                        references
+                            .peeled()
+                            .or_raise_erased(|| message!("Couldn't configure iterator for peeling"))?
+                            .filter_map(Result::ok)
+                            .filter(|r| r.id().header().ok().is_some_and(|obj| obj.kind().is_commit()))
+                            .filter_map(|r| r.detach().peeled),
+                    )
+                    .sorting(crate::revision::walk::Sorting::ByCommitTime(Default::default()))
+                    .all()
+                    .or_erased()?;
+                let mut matched = false;
+                let mut count = 0;
+                let commits = iter.map(|res| {
+                    res.map_err(|err| err.erased()).and_then(|commit| {
+                        commit
+                            .id()
+                            .object()
+                            .map_err(|err| err.erased())
+                            .map(Object::into_commit)
+                    })
+                });
+                for commit in commits {
+                    count += 1;
+                    match commit {
+                        Ok(commit) => {
+                            if matches(commit.message_raw_sloppy()) {
+                                let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
+                                if !objs.contains(&commit.id) {
+                                    objs.push(commit.id);
                                 }
-                            }
-                            Err(err) => {
-                                self.err.push(err.into());
-                                None
+                                matched = true;
+                                break;
                             }
                         }
+                        Err(err) => self.delayed_errors.push(err),
                     }
-                    Err(err) => {
-                        self.err.push(err.into());
-                        None
-                    }
-                },
-                Err(err) => {
-                    self.err.push(err.into());
-                    None
                 }
-            },
+                if matched {
+                    Ok(())
+                } else {
+                    Err(message!(
+                        "None of {commits_searched} commits reached from all references matched {kind} {regex:?}",
+                        regex = regex,
+                        commits_searched = count,
+                        kind = if cfg!(feature = "revparse-regex") {
+                            "regex"
+                        } else {
+                            "text"
+                        }
+                    )
+                    .erased())
+                }
+            }
         }
     }
 
-    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+    fn index_lookup(&mut self, path: &BStr, stage: u8) -> Result<(), Exn> {
         let stage = match stage {
             0 => Stage::Unconflicted,
             1 => Stage::Base,
@@ -317,44 +321,76 @@ impl delegate::Navigate for Delegate<'_> {
             ),
         };
         self.unset_disambiguate_call();
-        match self.repo.index() {
-            Ok(index) => match index.entry_by_path_and_stage(path, stage) {
-                Some(entry) => {
-                    self.objs[self.idx]
-                        .get_or_insert_with(HashSet::default)
-                        .insert(entry.id);
-
-                    self.paths[self.idx] = Some((
-                        path.to_owned(),
-                        entry
-                            .mode
-                            .to_tree_entry_mode()
-                            .unwrap_or(gix_object::tree::EntryKind::Blob.into()),
-                    ));
-                    Some(())
+        let index = self.repo.index().or_erased()?;
+        match index.entry_by_path_and_stage(path, stage) {
+            Some(entry) => {
+                let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
+                if !objs.contains(&entry.id) {
+                    objs.push(entry.id);
                 }
-                None => {
-                    let stage_hint = [Stage::Unconflicted, Stage::Base, Stage::Ours]
-                        .iter()
-                        .filter(|our_stage| **our_stage != stage)
-                        .find_map(|stage| index.entry_index_by_path_and_stage(path, *stage).map(|_| *stage));
-                    let exists = self
-                        .repo
-                        .workdir()
-                        .is_some_and(|root| root.join(gix_path::from_bstr(path)).exists());
-                    self.err.push(Error::IndexLookup {
-                        desired_path: path.into(),
-                        desired_stage: stage,
-                        exists,
-                        stage_hint,
-                    });
-                    None
-                }
-            },
-            Err(err) => {
-                self.err.push(err.into());
-                None
+
+                self.paths[self.idx] = Some((
+                    path.to_owned(),
+                    entry
+                        .mode
+                        .to_tree_entry_mode()
+                        .unwrap_or(gix_object::tree::EntryKind::Blob.into()),
+                ));
+                Ok(())
+            }
+            None => {
+                let stage_hint = [Stage::Unconflicted, Stage::Base, Stage::Ours]
+                    .iter()
+                    .filter(|our_stage| **our_stage != stage)
+                    .find_map(|stage| index.entry_index_by_path_and_stage(path, *stage).map(|_| *stage));
+                let exists = self
+                    .repo
+                    .workdir()
+                    .is_some_and(|root| root.join(gix_path::from_bstr(path)).exists());
+                Err(message!(
+                    "Path {path:?} did not exist in index at stage {desired_stage}{stage_hint}{exists}",
+                    exists = if exists {
+                        ". It exists on disk"
+                    } else {
+                        ". It does not exist on disk"
+                    },
+                    stage_hint = stage_hint
+                        .map(|actual| format!(". It does exist at stage {}", actual as u8))
+                        .unwrap_or_default(),
+                    desired_stage = stage as u8,
+                )
+                .erased())
+            }
+        }
+    }
+}
+
+fn handle_errors_and_replacements(
+    delayed_errors: &mut Vec<Exn>,
+    objs: &mut Vec<ObjectId>,
+    errors: Vec<(ObjectId, Exn)>,
+    replacements: &mut Replacements,
+) -> Result<(), Exn> {
+    if errors.len() == objs.len() {
+        delayed_errors.extend(errors.into_iter().map(|(_, err)| err));
+        Err(delayed_errors
+            .pop()
+            .unwrap_or_else(|| message!("BUG: Somehow there was no error but one was expected").erased()))
+    } else {
+        for (obj, err) in errors {
+            if let Some(pos) = objs.iter().position(|o| o == &obj) {
+                objs.remove(pos);
+            }
+            delayed_errors.push(err);
+        }
+        for (find, replace) in replacements {
+            if let Some(pos) = objs.iter().position(|o| o == find) {
+                objs.remove(pos);
+            }
+            if !objs.contains(replace) {
+                objs.push(*replace);
             }
         }
+        Ok(())
     }
 }
diff --git a/gix/src/revision/spec/parse/delegate/revision.rs b/gix/src/revision/spec/parse/delegate/revision.rs
index 8cecf217fa8..8bb93dac470 100644
--- a/gix/src/revision/spec/parse/delegate/revision.rs
+++ b/gix/src/revision/spec/parse/delegate/revision.rs
@@ -1,33 +1,33 @@
-use std::collections::HashSet;
-
+use gix_error::{bail, message, ErrorExt, Exn, ResultExt};
 use gix_hash::ObjectId;
 use gix_revision::spec::parse::{
     delegate,
     delegate::{ReflogLookup, SiblingBranch},
 };
+use std::collections::HashSet;
 
+use crate::revision::spec::parse::error;
 use crate::{
     bstr::{BStr, BString, ByteSlice},
     ext::ReferenceExt,
     remote,
-    revision::spec::parse::{Delegate, Error, RefsHint},
+    revision::spec::parse::{Delegate, RefsHint},
 };
 
 impl delegate::Revision for Delegate<'_> {
-    fn find_ref(&mut self, name: &BStr) -> Option<()> {
+    fn find_ref(&mut self, name: &BStr) -> Result<(), Exn> {
         self.unset_disambiguate_call();
-        if !self.err.is_empty() && self.refs[self.idx].is_some() {
-            return None;
+        if self.has_delayed_err() && self.refs[self.idx].is_some() {
+            return Err(message!("Refusing call as there are delayed errors and a ref is available").erased());
         }
         match self.repo.refs.find(name) {
             Ok(r) => {
                 assert!(self.refs[self.idx].is_none(), "BUG: cannot set the same ref twice");
                 self.refs[self.idx] = Some(r);
-                Some(())
+                Ok(())
             }
             Err(err) => {
-                self.err.push(err.into());
-                None
+                bail!(err.erased())
             }
         }
     }
@@ -36,43 +36,39 @@ impl delegate::Revision for Delegate<'_> {
         &mut self,
         prefix: gix_hash::Prefix,
         _must_be_commit: Option<delegate::PrefixHint<'_>>,
-    ) -> Option<()> {
+    ) -> Result<(), Exn> {
         self.last_call_was_disambiguate_prefix[self.idx] = true;
         let mut candidates = Some(HashSet::default());
         self.prefix[self.idx] = Some(prefix);
 
         let empty_tree_id = gix_hash::ObjectId::empty_tree(prefix.as_oid().kind());
-        let res = if prefix.as_oid() == empty_tree_id {
+        let ok = if prefix.as_oid() == empty_tree_id {
             candidates.as_mut().expect("set").insert(empty_tree_id);
             Ok(Some(Err(())))
         } else {
             self.repo.objects.lookup_prefix(prefix, candidates.as_mut())
-        };
+        }
+        .or_erased()?;
 
-        match res {
-            Err(err) => {
-                self.err.push(err.into());
-                None
-            }
-            Ok(None) => {
-                self.err.push(Error::PrefixNotFound { prefix });
-                None
-            }
-            Ok(Some(Ok(_) | Err(()))) => {
+        match ok {
+            None => Err(message!("An object prefixed {} could not be found", prefix).erased()),
+            Some(Ok(_) | Err(())) => {
                 assert!(self.objs[self.idx].is_none(), "BUG: cannot set the same prefix twice");
                 let candidates = candidates.expect("set above");
                 match self.opts.refs_hint {
                     RefsHint::PreferObjectOnFullLengthHexShaUseRefOtherwise
                         if prefix.hex_len() == candidates.iter().next().expect("at least one").kind().len_in_hex() =>
                     {
-                        self.ambiguous_objects[self.idx] = Some(candidates.clone());
-                        self.objs[self.idx] = Some(candidates);
-                        Some(())
+                        let objs = to_sorted_vec(candidates);
+                        self.ambiguous_objects[self.idx] = Some(objs.clone());
+                        self.objs[self.idx] = Some(objs);
+                        Ok(())
                     }
                     RefsHint::PreferObject => {
-                        self.ambiguous_objects[self.idx] = Some(candidates.clone());
-                        self.objs[self.idx] = Some(candidates);
-                        Some(())
+                        let objs = to_sorted_vec(candidates);
+                        self.ambiguous_objects[self.idx] = Some(objs.clone());
+                        self.objs[self.idx] = Some(objs);
+                        Ok(())
                     }
                     RefsHint::PreferRef | RefsHint::PreferObjectOnFullLengthHexShaUseRefOtherwise | RefsHint::Fail => {
                         match self.repo.refs.find(&prefix.to_string()) {
@@ -80,21 +76,24 @@ impl delegate::Revision for Delegate<'_> {
                                 assert!(self.refs[self.idx].is_none(), "BUG: cannot set the same ref twice");
                                 if self.opts.refs_hint == RefsHint::Fail {
                                     self.refs[self.idx] = Some(ref_.clone());
-                                    self.err.push(Error::AmbiguousRefAndObject {
-                                        prefix,
-                                        reference: ref_,
-                                    });
-                                    self.err.push(Error::ambiguous(candidates, prefix, self.repo));
-                                    None
+                                    self.delayed_errors.push(
+                                        message!(
+                                        "The short hash {prefix} matched both the reference {name} and at least one object",
+                                        name = ref_.name
+                                    )
+                                        .erased(),
+                                    );
+                                    Err(error::ambiguous(to_sorted_vec(candidates), prefix, self.repo).erased())
                                 } else {
                                     self.refs[self.idx] = Some(ref_);
-                                    Some(())
+                                    Ok(())
                                 }
                             }
                             Err(_) => {
-                                self.ambiguous_objects[self.idx] = Some(candidates.clone());
-                                self.objs[self.idx] = Some(candidates);
-                                Some(())
+                                let objs = to_sorted_vec(candidates);
+                                self.ambiguous_objects[self.idx] = Some(objs.clone());
+                                self.objs[self.idx] = Some(objs);
+                                Ok(())
                             }
                         }
                     }
@@ -103,7 +102,7 @@ impl delegate::Revision for Delegate<'_> {
         }
     }
 
-    fn reflog(&mut self, query: ReflogLookup) -> Option<()> {
+    fn reflog(&mut self, query: ReflogLookup) -> Result<(), Exn> {
         self.unset_disambiguate_call();
         let r = match &mut self.refs[self.idx] {
             Some(r) => r.clone().attach(self.repo),
@@ -112,14 +111,8 @@ impl delegate::Revision for Delegate<'_> {
                     *val = Some(r.clone().detach());
                     r
                 }
-                Ok(None) => {
-                    self.err.push(Error::UnbornHeadsHaveNoRefLog);
-                    return None;
-                }
-                Err(err) => {
-                    self.err.push(err.into());
-                    return None;
-                }
+                Ok(None) => return Err(message!("Unborn heads do not have a reflog yet").erased()),
+                Err(err) => return Err(err.erased()),
             },
         };
 
@@ -141,54 +134,49 @@ impl delegate::Revision for Delegate<'_> {
                     {
                         Some(closest_line) => closest_line.new_oid,
                         None => match last {
-                            None => {
-                                self.err.push(Error::EmptyReflog);
-                                return None;
-                            }
+                            None => return Err(message!("Reflog does not contain any entries").erased()),
                             Some(id) => id,
                         },
                     };
-                    self.objs[self.idx]
-                        .get_or_insert_with(HashSet::default)
-                        .insert(id_to_insert);
-                    Some(())
+                    let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
+                    if !objs.contains(&id_to_insert) {
+                        objs.push(id_to_insert);
+                    }
+                    Ok(())
                 }
                 ReflogLookup::Entry(no) => match it.nth(no).and_then(Result::ok) {
                     Some(line) => {
-                        self.objs[self.idx]
-                            .get_or_insert_with(HashSet::default)
-                            .insert(line.new_oid);
-                        Some(())
-                    }
-                    None => {
-                        let available = platform.rev().ok().flatten().map_or(0, Iterator::count);
-                        self.err.push(Error::RefLogEntryOutOfRange {
-                            reference: r.detach(),
-                            desired: no,
-                            available,
-                        });
-                        None
+                        let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
+                        if !objs.contains(&line.new_oid) {
+                            objs.push(line.new_oid);
+                        }
+                        Ok(())
                     }
+                    None => Err(message!(
+                        "Reference '{name}' has {available} ref-log entries and entry number {no} is out of range",
+                        name = r.name(),
+                        available = platform.rev().ok().flatten().map_or(0, Iterator::count)
+                    )
+                    .erased()),
                 },
             },
-            None => {
-                self.err.push(Error::MissingRefLog {
-                    reference: r.name().as_bstr().into(),
-                    action: match query {
-                        ReflogLookup::Entry(_) => "lookup reflog entry by index",
-                        ReflogLookup::Date(_) => "lookup reflog entry by date",
-                    },
-                });
-                None
-            }
+            None => Err(message!(
+                "Reference {reference:?} does not have a reference log, cannot {action}",
+                action = match query {
+                    ReflogLookup::Entry(_) => "lookup reflog entry by index",
+                    ReflogLookup::Date(_) => "lookup reflog entry by date",
+                },
+                reference = r.name().as_bstr()
+            )
+            .erased()),
         }
     }
 
-    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Option<()> {
+    fn nth_checked_out_branch(&mut self, branch_no: usize) -> Result<(), Exn> {
         self.unset_disambiguate_call();
         fn prior_checkouts_iter<'a>(
             platform: &'a mut gix_ref::file::log::iter::Platform<'static, '_>,
-        ) -> Result<impl Iterator<Item = (BString, ObjectId)> + 'a, Error> {
+        ) -> Result<impl Iterator<Item = (BString, ObjectId)> + 'a, gix_error::Error> {
             match platform.rev().ok().flatten() {
                 Some(log) => Ok(log.filter_map(Result::ok).filter_map(|line| {
                     line.message
@@ -196,22 +184,23 @@ impl delegate::Revision for Delegate<'_> {
                         .and_then(|from_to| from_to.find(" to ").map(|pos| &from_to[..pos]))
                         .map(|from_branch| (from_branch.into(), line.previous_oid))
                 })),
-                None => Err(Error::MissingRefLog {
-                    reference: "HEAD".into(),
-                    action: "search prior checked out branch",
-                }),
+                None => Err(message!(
+                    "Reference HEAD does not have a reference log, cannot search prior checked out branch",
+                )
+                .raise()
+                .into_error()),
             }
         }
 
         let head = match self.repo.head() {
             Ok(head) => head,
-            Err(err) => {
-                self.err.push(err.into());
-                return None;
-            }
+            Err(err) => return Err(err.erased()),
         };
-        match prior_checkouts_iter(&mut head.log_iter()).map(|mut it| it.nth(branch_no.saturating_sub(1))) {
-            Ok(Some((ref_name, id))) => {
+        let ok = prior_checkouts_iter(&mut head.log_iter())
+            .map(|mut it| it.nth(branch_no.saturating_sub(1)))
+            .or_erased()?;
+        match ok {
+            Some((ref_name, id)) => {
                 let id = match self.repo.find_reference(ref_name.as_bstr()) {
                     Ok(mut r) => {
                         let id = r.peel_to_id().map(crate::Id::detach).unwrap_or(id);
@@ -220,26 +209,23 @@ impl delegate::Revision for Delegate<'_> {
                     }
                     Err(_) => id,
                 };
-                self.objs[self.idx].get_or_insert_with(HashSet::default).insert(id);
-                Some(())
-            }
-            Ok(None) => {
-                self.err.push(Error::PriorCheckoutOutOfRange {
-                    desired: branch_no,
-                    available: prior_checkouts_iter(&mut head.log_iter())
-                        .map(Iterator::count)
-                        .unwrap_or(0),
-                });
-                None
-            }
-            Err(err) => {
-                self.err.push(err);
-                None
+                let objs = self.objs[self.idx].get_or_insert_with(Vec::new);
+                if !objs.contains(&id) {
+                    objs.push(id);
+                }
+                Ok(())
             }
+            None => Err(message!(
+                "HEAD has {available} prior checkouts and checkout number {branch_no} is out of range",
+                available = prior_checkouts_iter(&mut head.log_iter())
+                    .map(Iterator::count)
+                    .unwrap_or(0)
+            )
+            .erased()),
         }
     }
 
-    fn sibling_branch(&mut self, kind: SiblingBranch) -> Option<()> {
+    fn sibling_branch(&mut self, kind: SiblingBranch) -> Result<(), Exn> {
         self.unset_disambiguate_call();
         let reference = match &mut self.refs[self.idx] {
             val @ None => match self.repo.head().map(crate::Head::try_into_referent) {
@@ -248,12 +234,10 @@ impl delegate::Revision for Delegate<'_> {
                     r
                 }
                 Ok(None) => {
-                    self.err.push(Error::UnbornHeadForSibling);
-                    return None;
+                    return Err(message!("Unborn heads cannot have push or upstream tracking branches").erased())
                 }
                 Err(err) => {
-                    self.err.push(err.into());
-                    return None;
+                    return Err(err.erased());
                 }
             },
             Some(r) => r.clone().attach(self.repo),
@@ -262,28 +246,37 @@ impl delegate::Revision for Delegate<'_> {
             SiblingBranch::Upstream => remote::Direction::Fetch,
             SiblingBranch::Push => remote::Direction::Push,
         };
+        let make_message = || {
+            message!(
+                "Error when obtaining {direction} tracking branch for {name}",
+                name = reference.name().as_bstr(),
+                direction = direction.as_str()
+            )
+        };
         match reference.remote_tracking_ref_name(direction) {
-            None => self.err.push(Error::NoTrackingBranch {
-                name: reference.inner.name,
-                direction,
-            }),
-            Some(Err(err)) => self.err.push(Error::GetTrackingBranch {
-                name: reference.inner.name,
-                direction,
-                source: Box::new(err),
-            }),
+            None => self.delayed_errors.push(
+                message!(
+                    "Branch named {name} does not have a {direction} tracking branch configured",
+                    name = reference.name().as_bstr(),
+                    direction = direction.as_str()
+                )
+                .erased(),
+            ),
+            Some(Err(err)) => self.delayed_errors.push(err.raise().raise(make_message()).erased()),
             Some(Ok(name)) => match self.repo.find_reference(name.as_ref()) {
-                Err(err) => self.err.push(Error::GetTrackingBranch {
-                    name: reference.inner.name,
-                    direction,
-                    source: Box::new(err),
-                }),
+                Err(err) => self.delayed_errors.push(err.raise().raise(make_message()).erased()),
                 Ok(r) => {
                     self.refs[self.idx] = r.inner.into();
-                    return Some(());
+                    return Ok(());
                 }
             },
         }
-        None
+        Err(message!("Couldn't find sibling of {kind:?}", kind = kind).erased())
     }
 }
+
+fn to_sorted_vec(objs: HashSet<ObjectId>) -> Vec<ObjectId> {
+    let mut v: Vec<_> = objs.into_iter().collect();
+    v.sort();
+    v
+}
diff --git a/gix/src/revision/spec/parse/error.rs b/gix/src/revision/spec/parse/error.rs
index 3cbcab3353d..5f05d56d6dd 100644
--- a/gix/src/revision/spec/parse/error.rs
+++ b/gix/src/revision/spec/parse/error.rs
@@ -1,8 +1,6 @@
-use std::collections::HashSet;
-
+use gix_error::message;
 use gix_hash::ObjectId;
 
-use super::Error;
 use crate::{bstr, bstr::BString, ext::ObjectIdExt, Repository};
 
 /// Additional information about candidates that caused ambiguity.
@@ -51,95 +49,76 @@ impl std::fmt::Display for CandidateInfo {
     }
 }
 
-impl Error {
-    pub(crate) fn ambiguous(candidates: HashSet<ObjectId>, prefix: gix_hash::Prefix, repo: &Repository) -> Self {
-        #[derive(PartialOrd, Ord, Eq, PartialEq, Copy, Clone)]
-        enum Order {
-            Tag,
-            Commit,
-            Tree,
-            Blob,
-            Invalid,
-        }
-        let candidates = {
-            let mut c: Vec<_> = candidates
-                .into_iter()
-                .map(|oid| {
-                    let obj = repo.find_object(oid);
-                    let order = match &obj {
-                        Err(_) => Order::Invalid,
-                        Ok(obj) => match obj.kind {
-                            gix_object::Kind::Tag => Order::Tag,
-                            gix_object::Kind::Commit => Order::Commit,
-                            gix_object::Kind::Tree => Order::Tree,
-                            gix_object::Kind::Blob => Order::Blob,
-                        },
-                    };
-                    (oid, obj, order)
-                })
-                .collect();
-            c.sort_by(|lhs, rhs| lhs.2.cmp(&rhs.2).then_with(|| lhs.0.cmp(&rhs.0)));
-            c
-        };
-        Error::AmbiguousPrefix {
-            prefix,
-            info: candidates
-                .into_iter()
-                .map(|(oid, find_result, _)| {
-                    let info = match find_result {
-                        Ok(obj) => match obj.kind {
-                            gix_object::Kind::Tree | gix_object::Kind::Blob => CandidateInfo::Object { kind: obj.kind },
-                            gix_object::Kind::Tag => {
-                                let tag = obj.to_tag_ref();
-                                CandidateInfo::Tag { name: tag.name.into() }
-                            }
-                            gix_object::Kind::Commit => {
-                                use bstr::ByteSlice;
-                                let commit = obj.to_commit_ref();
-                                let date = match commit.committer() {
-                                    Ok(signature) => signature.time.trim().to_owned(),
-                                    Err(_) => {
-                                        let committer = commit.committer;
-                                        let manually_parsed_best_effort = committer
-                                            .rfind_byte(b'>')
-                                            .map(|pos| committer[pos + 1..].trim().as_bstr().to_string());
-                                        manually_parsed_best_effort.unwrap_or_default()
-                                    }
-                                };
-                                CandidateInfo::Commit {
-                                    date,
-                                    title: commit.message().title.trim().into(),
-                                }
-                            }
-                        },
-                        Err(err) => CandidateInfo::FindError { source: err },
-                    };
-                    (oid.attach(repo).shorten().unwrap_or_else(|_| oid.into()), info)
-                })
-                .collect(),
-        }
+pub(crate) fn ambiguous(candidates: Vec<ObjectId>, prefix: gix_hash::Prefix, repo: &Repository) -> gix_error::Message {
+    #[derive(PartialOrd, Ord, Eq, PartialEq, Copy, Clone)]
+    enum Order {
+        Tag,
+        Commit,
+        Tree,
+        Blob,
+        Invalid,
     }
-
-    pub(crate) fn from_errors(errors: Vec<Self>) -> Self {
-        match errors.len() {
-            0 => unreachable!(
-                "BUG: cannot create something from nothing, must have recorded some errors to call from_errors()"
-            ),
-            1 => errors.into_iter().next().expect("one"),
-            _ => {
-                let mut it = errors.into_iter().rev();
-                let mut recent = Error::Multi {
-                    current: Box::new(it.next().expect("at least one error")),
-                    next: None,
+    let candidates = {
+        let mut c: Vec<_> = candidates
+            .into_iter()
+            .map(|oid| {
+                let obj = repo.find_object(oid);
+                let order = match &obj {
+                    Err(_) => Order::Invalid,
+                    Ok(obj) => match obj.kind {
+                        gix_object::Kind::Tag => Order::Tag,
+                        gix_object::Kind::Commit => Order::Commit,
+                        gix_object::Kind::Tree => Order::Tree,
+                        gix_object::Kind::Blob => Order::Blob,
+                    },
                 };
-                for err in it {
-                    recent = Error::Multi {
-                        current: Box::new(err),
-                        next: Some(Box::new(recent)),
+                (oid, obj, order)
+            })
+            .collect();
+        c.sort_by(|lhs, rhs| lhs.2.cmp(&rhs.2).then_with(|| lhs.0.cmp(&rhs.0)));
+        c
+    };
+    let info: Vec<_> = candidates
+        .into_iter()
+        .map(|(oid, find_result, _)| {
+            let info = match find_result {
+                Ok(obj) => match obj.kind {
+                    gix_object::Kind::Tree | gix_object::Kind::Blob => CandidateInfo::Object { kind: obj.kind },
+                    gix_object::Kind::Tag => {
+                        let tag = obj.to_tag_ref();
+                        CandidateInfo::Tag { name: tag.name.into() }
                     }
-                }
-                recent
-            }
-        }
-    }
+                    gix_object::Kind::Commit => {
+                        use bstr::ByteSlice;
+                        let commit = obj.to_commit_ref();
+                        let date = match commit.committer() {
+                            Ok(signature) => signature.time.trim().to_owned(),
+                            Err(_) => {
+                                let committer = commit.committer;
+                                let manually_parsed_best_effort = committer
+                                    .rfind_byte(b'>')
+                                    .map(|pos| committer[pos + 1..].trim().as_bstr().to_string());
+                                manually_parsed_best_effort.unwrap_or_default()
+                            }
+                        };
+                        CandidateInfo::Commit {
+                            date,
+                            title: commit.message().title.trim().into(),
+                        }
+                    }
+                },
+                Err(err) => CandidateInfo::FindError { source: err },
+            };
+            (oid.attach(repo).shorten().unwrap_or_else(|_| oid.into()), info)
+        })
+        .collect();
+    message!(
+        "Short id {prefix} is ambiguous. Candidates are:\n{info}",
+        prefix = prefix,
+        info = info
+            .iter()
+            .map(|(oid, info)| format!("\t{oid} {info}"))
+            .collect::<Vec<_>>()
+            .join("\n")
+    )
 }
diff --git a/gix/src/revision/spec/parse/mod.rs b/gix/src/revision/spec/parse/mod.rs
index 68cdf5e7ea3..bd43cdb3d7a 100644
--- a/gix/src/revision/spec/parse/mod.rs
+++ b/gix/src/revision/spec/parse/mod.rs
@@ -1,12 +1,9 @@
-use std::collections::HashSet;
-
-use gix_hash::ObjectId;
-use gix_revision::spec::parse;
-
 use crate::{bstr::BStr, revision::Spec, Repository};
+use gix_error::Exn;
+use gix_hash::ObjectId;
 
 mod types;
-pub use types::{Error, ObjectKindHint, Options, RefsHint};
+pub use types::{ObjectKindHint, Options, RefsHint};
 
 use crate::bstr::BString;
 
@@ -19,7 +16,7 @@ pub mod single {
     #[allow(missing_docs)]
     pub enum Error {
         #[error(transparent)]
-        Parse(#[from] super::Error),
+        Parse(#[from] gix_error::Error),
         #[error("revspec {spec:?} did not resolve to a single object")]
         RangedRev { spec: BString },
     }
@@ -32,11 +29,21 @@ impl<'repo> Spec<'repo> {
     /// Parse `spec` and use information from `repo` to resolve it, using `opts` to learn how to deal with ambiguity.
     ///
     /// Note that it's easier and to use [`repo.rev_parse()`][Repository::rev_parse()] instead.
-    pub fn from_bstr<'a>(spec: impl Into<&'a BStr>, repo: &'repo Repository, opts: Options) -> Result<Self, Error> {
+    pub fn from_bstr<'a>(
+        spec: impl Into<&'a BStr>,
+        repo: &'repo Repository,
+        opts: Options,
+    ) -> Result<Self, gix_error::Error> {
         let mut delegate = Delegate::new(repo, opts);
         match gix_revision::spec::parse(spec.into(), &mut delegate) {
-            Err(parse::Error::Delegate) => Err(delegate.into_err()),
-            Err(err) => Err(err.into()),
+            Err(mut err) => {
+                if let Some(delegate_err) = delegate.into_delayed_errors() {
+                    let sources: Vec<_> = err.drain_children().collect();
+                    Err(err.chain(delegate_err.chain_iter(sources)).into_error())
+                } else {
+                    Err(err.into_error())
+                }
+            }
             Ok(()) => delegate.into_rev_spec(),
         }
     }
@@ -44,17 +51,18 @@ impl<'repo> Spec<'repo> {
 
 struct Delegate<'repo> {
     refs: [Option<gix_ref::Reference>; 2],
-    objs: [Option<HashSet<ObjectId>>; 2],
+    objs: [Option<Vec<ObjectId>>; 2],
     /// Path specified like `@:<path>` or `:<path>` for later use when looking up specs.
     /// Note that it terminates spec parsing, so it's either `0` or `1`, never both.
     paths: [Option<(BString, gix_object::tree::EntryMode)>; 2],
     /// The originally encountered ambiguous objects for potential later use in errors.
-    ambiguous_objects: [Option<HashSet<ObjectId>>; 2],
+    ambiguous_objects: [Option<Vec<ObjectId>>; 2],
     idx: usize,
     kind: Option<gix_revision::spec::Kind>,
 
     opts: Options,
-    err: Vec<Error>,
+    /// Keeps track of errors that are supposed to be returned later.
+    delayed_errors: Vec<Exn>,
     /// The ambiguous prefix obtained during a call to `disambiguate_prefix()`.
     prefix: [Option<gix_hash::Prefix>; 2],
     /// If true, we didn't try to do any other transformation which might have helped with disambiguation.
diff --git a/gix/src/revision/spec/parse/types.rs b/gix/src/revision/spec/parse/types.rs
index 1045364eb13..7dc947dfe17 100644
--- a/gix/src/revision/spec/parse/types.rs
+++ b/gix/src/revision/spec/parse/types.rs
@@ -1,5 +1,3 @@
-use crate::{bstr::BString, object, reference, remote};
-
 /// A hint to know what to do if refs and object names are equal.
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum RefsHint {
@@ -50,150 +48,3 @@ pub struct Options {
     /// other disambiguating transformations.
     pub object_kind_hint: Option<ObjectKindHint>,
 }
-
-/// The error returned by [`crate::Repository::rev_parse()`].
-#[derive(Debug, thiserror::Error)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("Could not peel '{}' to obtain its target", name)]
-    PeelToId {
-        name: gix_ref::FullName,
-        source: reference::peel::Error,
-    },
-    #[error("The rev-spec is malformed and misses a ref name")]
-    Malformed,
-    #[error("Unborn heads do not have a reflog yet")]
-    UnbornHeadsHaveNoRefLog,
-    #[error("Unborn heads cannot have push or upstream tracking branches")]
-    UnbornHeadForSibling,
-    #[error("Branch named {name} does not have a {} tracking branch configured", direction.as_str())]
-    NoTrackingBranch {
-        name: gix_ref::FullName,
-        direction: remote::Direction,
-    },
-    #[error("Error when obtaining {} tracking branch for {name}", direction.as_str())]
-    GetTrackingBranch {
-        name: gix_ref::FullName,
-        direction: remote::Direction,
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-    #[error("Reference {reference:?} does not have a reference log, cannot {action}")]
-    MissingRefLog { reference: BString, action: &'static str },
-    #[error("HEAD has {available} prior checkouts and checkout number {desired} is out of range")]
-    PriorCheckoutOutOfRange { desired: usize, available: usize },
-    #[error("Reference {:?} has {available} ref-log entries and entry number {desired} is out of range", reference.name.as_bstr())]
-    RefLogEntryOutOfRange {
-        reference: gix_ref::Reference,
-        desired: usize,
-        available: usize,
-    },
-    #[error(
-        "Commit {oid} has {available} ancestors along the first parent and ancestor number {desired} is out of range"
-    )]
-    AncestorOutOfRange {
-        oid: gix_hash::Prefix,
-        desired: usize,
-        available: usize,
-    },
-    #[error("Commit {oid} has {available} parents and parent number {desired} is out of range")]
-    ParentOutOfRange {
-        oid: gix_hash::Prefix,
-        desired: usize,
-        available: usize,
-    },
-    #[error("Path {desired_path:?} did not exist in index at stage {}{}{}", *desired_stage as u8, stage_hint.map(|actual|format!(". It does exist at stage {}", actual as u8)).unwrap_or_default(), exists.then(|| ". It exists on disk").unwrap_or(". It does not exist on disk"))]
-    IndexLookup {
-        desired_path: BString,
-        desired_stage: gix_index::entry::Stage,
-        stage_hint: Option<gix_index::entry::Stage>,
-        exists: bool,
-    },
-    #[error(transparent)]
-    FindHead(#[from] reference::find::existing::Error),
-    #[error(transparent)]
-    Index(#[from] crate::worktree::open_index::Error),
-    #[error(transparent)]
-    RevWalkIterInit(#[from] crate::reference::iter::init::Error),
-    #[error(transparent)]
-    RevWalkAllReferences(#[from] gix_ref::packed::buffer::open::Error),
-    #[cfg(feature = "revparse-regex")]
-    #[error(transparent)]
-    InvalidRegex(#[from] regex::Error),
-    #[cfg_attr(
-        feature = "revparse-regex",
-        error("None of {commits_searched} commits from {oid} matched regex {regex:?}")
-    )]
-    #[cfg_attr(
-        not(feature = "revparse-regex"),
-        error("None of {commits_searched} commits from {oid} matched text {regex:?}")
-    )]
-    NoRegexMatch {
-        regex: BString,
-        oid: gix_hash::Prefix,
-        commits_searched: usize,
-    },
-    #[cfg_attr(
-        feature = "revparse-regex",
-        error("None of {commits_searched} commits reached from all references matched regex {regex:?}")
-    )]
-    #[cfg_attr(
-        not(feature = "revparse-regex"),
-        error("None of {commits_searched} commits reached from all references matched text {regex:?}")
-    )]
-    NoRegexMatchAllRefs { regex: BString, commits_searched: usize },
-    #[error(
-    "The short hash {prefix} matched both the reference {} and at least one object", reference.name)]
-    AmbiguousRefAndObject {
-        /// The prefix to look for.
-        prefix: gix_hash::Prefix,
-        /// The reference matching the prefix.
-        reference: gix_ref::Reference,
-    },
-    #[error(transparent)]
-    IdFromHex(#[from] gix_hash::decode::Error),
-    #[error(transparent)]
-    FindReference(#[from] gix_ref::file::find::existing::Error),
-    #[error(transparent)]
-    FindObject(#[from] object::find::existing::Error),
-    #[error(transparent)]
-    LookupPrefix(#[from] gix_odb::store::prefix::lookup::Error),
-    #[error(transparent)]
-    PeelToKind(#[from] object::peel::to_kind::Error),
-    #[error("Object {oid} was a {actual}, but needed it to be a {expected}")]
-    ObjectKind {
-        oid: gix_hash::Prefix,
-        actual: gix_object::Kind,
-        expected: gix_object::Kind,
-    },
-    #[error(transparent)]
-    Parse(#[from] gix_revision::spec::parse::Error),
-    #[error("An object prefixed {prefix} could not be found")]
-    PrefixNotFound { prefix: gix_hash::Prefix },
-    #[error("Short id {prefix} is ambiguous. Candidates are:\n{}", info.iter().map(|(oid, info)| format!("\t{oid} {info}")).collect::<Vec<_>>().join("\n"))]
-    AmbiguousPrefix {
-        prefix: gix_hash::Prefix,
-        info: Vec<(gix_hash::Prefix, super::error::CandidateInfo)>,
-    },
-    #[error("Could not find path {path:?} in tree {tree} of parent object {object}")]
-    PathNotFound {
-        object: gix_hash::Prefix,
-        tree: gix_hash::Prefix,
-        path: BString,
-    },
-    #[error("{current}")]
-    Multi {
-        current: Box<dyn std::error::Error + Send + Sync + 'static>,
-        #[source]
-        next: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
-    },
-    #[error(transparent)]
-    Traverse(#[from] crate::revision::walk::iter::Error),
-    #[error("Tried to navigate the commit-graph without providing an anchor first")]
-    TraversalWithoutStartObject,
-    #[error(transparent)]
-    Walk(#[from] crate::revision::walk::Error),
-    #[error("Spec does not contain a single object id")]
-    SingleNotFound,
-    #[error("Reflog does not contain any entries")]
-    EmptyReflog,
-}
diff --git a/gix/src/tag.rs b/gix/src/tag.rs
index a69819b510f..80fa5625e14 100644
--- a/gix/src/tag.rs
+++ b/gix/src/tag.rs
@@ -13,7 +13,7 @@ mod error {
         #[error(transparent)]
         ReferenceEdit(#[from] crate::reference::edit::Error),
         #[error(transparent)]
-        DateParseError(#[from] gix_date::parse::Error),
+        DateParseError(#[from] gix_date::Error),
     }
 }
 pub use error::Error;
diff --git a/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs b/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
index 68ed163745e..2e018a7a35b 100644
--- a/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/ambiguous.rs
@@ -1,11 +1,3 @@
-use gix::{
-    prelude::{ObjectIdExt, RevSpecExt},
-    revision::{
-        spec::parse::{Options, RefsHint},
-        Spec,
-    },
-};
-
 use super::repo;
 use crate::{
     revision::spec::from_bytes::{
@@ -14,17 +6,24 @@ use crate::{
     },
     util::hex_to_id,
 };
+use gix::{
+    prelude::{ObjectIdExt, RevSpecExt},
+    revision::{
+        spec::parse::{Options, RefsHint},
+        Spec,
+    },
+};
 
 #[test]
 fn prefix() {
     {
         let repo = repo("blob.prefix").unwrap();
         assert_eq!(
-            parse_spec("dead", &repo).unwrap_err().to_string(),
+            parse_spec("dead", &repo).unwrap_err().probable_cause().to_string(),
             "Short id dead is ambiguous. Candidates are:\n\tdead7b2 blob\n\tdead9d3 blob"
         );
         assert_eq!(
-            parse_spec("beef", &repo).unwrap_err().to_string(),
+            parse_spec("beef", &repo).unwrap_err().probable_cause().to_string(),
             "Short id beef is ambiguous. Candidates are:\n\tbeef2b0 blob\n\tbeefc9b blob"
         );
     }
@@ -32,7 +31,7 @@ fn prefix() {
     {
         let repo = repo("blob.bad").unwrap();
         assert_eq!(
-            parse_spec("bad0", &repo).unwrap_err().to_string(),
+            parse_spec("bad0", &repo).unwrap_err().probable_cause().to_string(),
             "Short id bad0 is ambiguous. Candidates are:\n\tbad0853 lookup error: An error occurred while obtaining an object from the loose object store\n\tbad0bd4 lookup error: An error occurred while obtaining an object from the loose object store",
             "git provides a much worse hint messages and fails to provide information for both bad objects"
         );
@@ -42,8 +41,29 @@ fn prefix() {
 #[test]
 fn fully_failed_disambiguation_still_yields_an_ambiguity_error() {
     let repo = repo("ambiguous_blob_tree_commit").unwrap();
+    let err = parse_spec("0000000000^{tag}", &repo).unwrap_err();
+
+    insta::assert_debug_snapshot!(err, @r#"
+    delegate.peel_until(ObjectKind(Tag)) failed: {tag}
+    |
+    └─ Short id 0000000000 is ambiguous. Candidates are:
+    	0000000000e commit 2005-04-07 "a2onsxbvj"
+    	0000000000c tree
+    	0000000000b blob
+    |
+    └─ Last encountered object 0000000000c was tree while trying to peel to tag
+    "#);
+
+    insta::assert_snapshot!(format!("{err:#}"), @r#"
+    ParseError { message: "delegate.peel_until(ObjectKind(Tag)) failed", input: Some("{tag}") }
+    |
+    └─ Message("Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob")
+        |
+        └─ NotFound { oid: Prefix { bytes: Sha1(0000000000c00000000000000000000000000000), hex_len: 11 }, actual: Tree, expected: Tag }
+    "#);
+    use std::error::Error;
     assert_eq!(
-        parse_spec("0000000000^{tag}", &repo).unwrap_err().to_string(),
+        err.source().expect("ambiguity error").to_string(),
         "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
         "without special treatment, one would see a bunch of failed transformations with the impression that the first of them is the root cause, which isn't correct."
     );
@@ -73,7 +93,7 @@ fn ranges_are_auto_disambiguated_by_committish() {
 fn blob_and_tree_can_be_disambiguated_by_type() {
     let repo = repo("ambiguous_blob_tree_commit").unwrap();
     assert_eq!(
-        parse_spec("0000000000", &repo).unwrap_err().to_string(),
+        parse_spec("0000000000", &repo).unwrap_err().probable_cause().to_string(),
         "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t0000000000c tree\n\t0000000000b blob",
         "in theory one could disambiguate with 0000000000^{{tree}} (which works in git) or 0000000000^{{blob}} which doesn't work for some reason."
     );
@@ -143,7 +163,7 @@ fn tags_can_be_disambiguated_with_commit_specific_transformations() {
 fn duplicates_are_deduplicated_across_all_odb_types() {
     let repo = repo("duplicate_ambiguous_objects").unwrap();
     assert_eq!(
-        parse_spec_no_baseline("0000000000", &repo).unwrap_err().to_string(),
+        parse_spec_no_baseline("0000000000", &repo).unwrap_err().probable_cause().to_string(),
         "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\"\n\t000000000002 tree\n\t00000000005 tree\n\t00000000009 tree\n\t0000000000c tree\n\t0000000000fd tree\n\t00000000001 blob\n\t00000000003 blob\n\t0000000000a blob\n\t0000000000b blob\n\t0000000000f2 blob",
         "One day we want to see 16 objects here, and not 32 just because they exist in the loose and the packed odb"
     );
@@ -184,7 +204,7 @@ fn ambiguous_40hex_refs_are_ignored_and_we_prefer_the_object_of_the_same_name()
             &repo,
             opts_ref_hint(RefsHint::Fail)
         )
-            .unwrap_err()
+            .unwrap_err().probable_cause()
             .to_string(),
         "The short hash 0000000000e4f9fbd19cf1e932319e5ad0d1d00b matched both the reference refs/heads/0000000000e4f9fbd19cf1e932319e5ad0d1d00b and at least one object"
     );
@@ -215,6 +235,7 @@ fn ambiguous_short_refs_are_dereferenced() {
     assert_eq!(
         parse_spec_no_baseline_opts(spec, &repo, opts_ref_hint(RefsHint::Fail))
             .unwrap_err()
+            .probable_cause()
             .to_string(),
         "The short hash 0000000000e matched both the reference refs/heads/0000000000e and at least one object",
         "users who don't want this ambiguity, could fail like this."
@@ -229,14 +250,29 @@ fn repository_local_disambiguation_hints_disambiguate() {
         Spec::from_id(hex_to_id("0000000000f8f5507ab27a0d7bd3c75c0f64ffe0").attach(&r)),
         "we read the 'core.disambiguate' value and apply it to auto-disambiguate"
     );
+    let err = rev_parse("0000000000", &r).unwrap_err();
+    insta::assert_debug_snapshot!(err, @r#"
+    Short id 0000000000 is ambiguous. Candidates are:
+    	0000000000f8 tag "v1.0.0"
+    	000000000004 commit 2005-04-07 "czy8f73t"
+    	00000000006 commit 2005-04-07 "ad2uee"
+    	00000000008 commit 2005-04-07 "ioiley5o"
+    	0000000000e commit 2005-04-07 "a2onsxbvj"
+    "#);
     assert_eq!(
-        rev_parse("0000000000", &r).unwrap_err().to_string(),
+        err.to_string(),
         "Short id 0000000000 is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t000000000004 commit 2005-04-07 \"czy8f73t\"\n\t00000000006 commit 2005-04-07 \"ad2uee\"\n\t00000000008 commit 2005-04-07 \"ioiley5o\"\n\t0000000000e commit 2005-04-07 \"a2onsxbvj\""
     );
 
     let r = repo("ambiguous_objects_disambiguation_config_treeish").unwrap();
+    let err = rev_parse("0000000000f", &r).unwrap_err();
+    insta::assert_debug_snapshot!(err, @r#"
+    Short id 0000000000f is ambiguous. Candidates are:
+    	0000000000f8 tag "v1.0.0"
+    	0000000000fd tree
+    "#);
     assert_eq!(
-        rev_parse("0000000000f", &r).unwrap_err().to_string(),
+        err.to_string(),
         "Short id 0000000000f is ambiguous. Candidates are:\n\t0000000000f8 tag \"v1.0.0\"\n\t0000000000fd tree",
         "disambiguation might not always work either."
     );
@@ -278,8 +314,14 @@ fn repository_local_disambiguation_hints_disambiguate() {
 #[test]
 fn repository_local_disambiguation_hints_are_overridden_by_specific_ones() {
     let repo = repo("ambiguous_objects_disambiguation_config_committish").unwrap();
+    let err = rev_parse("0000000000f^{tree}", &repo).unwrap_err();
+    insta::assert_debug_snapshot!(err, @r"
+    Short id 0000000000f is ambiguous. Candidates are:
+    	0000000000c tree
+    	0000000000fd tree
+    ");
     assert_eq!(
-        rev_parse("0000000000f^{tree}", &repo).unwrap_err().to_string(),
+        err.to_string(),
         "Short id 0000000000f is ambiguous. Candidates are:\n\t0000000000c tree\n\t0000000000fd tree",
         "spec overrides overrule the configuration value, which makes this particular object ambiguous between tree and tag"
     );
diff --git a/gix/tests/gix/revision/spec/from_bytes/mod.rs b/gix/tests/gix/revision/spec/from_bytes/mod.rs
index c728932d8d1..2755ff00f25 100644
--- a/gix/tests/gix/revision/spec/from_bytes/mod.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/mod.rs
@@ -61,19 +61,25 @@ mod index {
             "index paths (that are present) are captured"
         );
 
+        let err = parse_spec(":1:file", &repo).unwrap_err();
+        insta::assert_debug_snapshot!(err, @r#"
+        Couldn't find index 'file' stage 1
+        |
+        └─ Path "file" did not exist in index at stage 1. It does exist at stage 0. It exists on disk
+        "#);
         assert_eq!(
-            parse_spec(":1:file", &repo).unwrap_err().to_string(),
+            err.probable_cause().to_string(),
             "Path \"file\" did not exist in index at stage 1. It does exist at stage 0. It exists on disk",
         );
 
         assert_eq!(
-            parse_spec(":5:file", &repo).unwrap_err().to_string(),
+            parse_spec(":5:file", &repo).unwrap_err().probable_cause().to_string(),
             "Path \"5:file\" did not exist in index at stage 0. It does not exist on disk",
             "invalid stage ids are interpreted as part of the filename"
         );
 
         assert_eq!(
-            parse_spec(":foo", &repo).unwrap_err().to_string(),
+            parse_spec(":foo", &repo).unwrap_err().probable_cause().to_string(),
             "Path \"foo\" did not exist in index at stage 0. It does not exist on disk",
         );
     }
@@ -112,11 +118,21 @@ fn bad_objects_are_valid_until_they_are_actually_read_from_the_odb() {
             Spec::from_id(hex_to_id("e32851d29feb48953c6f40b2e06d630a3c49608a").attach(&repo)),
             "we are able to return objects even though they are 'bad' when trying to decode them, like git",
         );
+        let err = parse_spec("e328^{object}", &repo).unwrap_err();
         assert_eq!(
-            format!("{:?}", parse_spec("e328^{object}", &repo).unwrap_err()),
-            r#"FindObject(Find(Loose(Decode(ObjectHeader(InvalidObjectKind { kind: "bad" })))))"#,
+            format!("{:?}", err.probable_cause()),
+            r#"InvalidObjectKind { kind: "bad" }"#,
             "Now we enforce the object to exist and be valid, as ultimately it wants to match with a certain type"
         );
+        insta::assert_debug_snapshot!(err, @r#"
+        delegate.peel_until(ValidObject) failed: {object}
+        |
+        └─ An error occurred while obtaining an object from the loose object store
+        |
+        └─ The object header contained an unknown object kind.
+        |
+        └─ Unknown object kind: "bad"
+        "#);
     }
 
     {
@@ -125,10 +141,18 @@ fn bad_objects_are_valid_until_they_are_actually_read_from_the_odb() {
             parse_spec("cafea", &repo).unwrap(),
             Spec::from_id(hex_to_id("cafea31147e840161a1860c50af999917ae1536b").attach(&repo))
         );
-        assert_eq!(
-            &format!("{:?}", parse_spec("cafea^{object}", &repo).unwrap_err())[..65],
-            r#"FindObject(Find(Loose(DecompressFile { source: Inflate(DataError)"#
-        );
+        let err = parse_spec("cafea^{object}", &repo).unwrap_err();
+        insta::assert_snapshot!(format!("{err:#?}").replace('\\', "/").replace("windows", "unix"), @r"
+        delegate.peel_until(ValidObject) failed: {object}
+        |
+        └─ An error occurred while obtaining an object from the loose object store
+        |
+        └─ decompression of loose object at 'tests/fixtures/generated-do-not-edit/make_rev_spec_parse_repos/2990428670-unix/blob.corrupt/objects/ca/fea31147e840161a1860c50af999917ae1536b' failed
+        |
+        └─ Could not decode zip stream, status was 'Invalid input data'
+        |
+        └─ Invalid input data
+        ");
     }
 }
 
@@ -146,8 +170,14 @@ fn access_blob_through_tree() {
         "we capture tree-paths"
     );
 
+    let err = parse_spec("0000000000cdc:missing", &repo).unwrap_err();
+    insta::assert_debug_snapshot!(err, @r#"
+    delegate.peel_until(Path("missing")) failed
+    |
+    └─ Could not find path "missing" in tree 0000000000c of parent object 0000000000c
+    "#);
     assert_eq!(
-        parse_spec("0000000000cdc:missing", &repo).unwrap_err().to_string(),
+        err.probable_cause().to_string(),
         "Could not find path \"missing\" in tree 0000000000c of parent object 0000000000c"
     );
 }
@@ -156,10 +186,22 @@ fn access_blob_through_tree() {
 fn invalid_head() {
     let repo = repo("invalid-head").unwrap();
     let err = parse_spec("HEAD:file", &repo).unwrap_err();
-    assert_eq!(err.to_string(), "Could not peel 'HEAD' to obtain its target");
+    insta::assert_debug_snapshot!(err, @r#"
+    delegate.peel_until(Path("file")) failed
+    |
+    └─ Could not peel 'HEAD' to obtain its target
+        |
+        └─ Could not follow a single level of a symbolic reference
+        |   |
+        |   └─ The ref partially named "refs/heads/main" could not be found
+        |
+        └─ Couldn't get object at internal index 0
+    "#);
 
     let err = parse_spec("HEAD", &repo).unwrap_err();
-    assert_eq!(err.to_string(), "The rev-spec is malformed and misses a ref name");
+    // The head couldn't be peeled, and there is nothing left to consume, but no
+    // object was resolved.
+    insta::assert_debug_snapshot!(err, @"The rev-spec is malformed and misses a ref name");
 }
 
 #[test]
diff --git a/gix/tests/gix/revision/spec/from_bytes/reflog.rs b/gix/tests/gix/revision/spec/from_bytes/reflog.rs
index ce8c934549b..10962b74b77 100644
--- a/gix/tests/gix/revision/spec/from_bytes/reflog.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/reflog.rs
@@ -22,7 +22,7 @@ fn nth_prior_checkout() {
     }
 
     assert_eq!(
-        parse_spec("@{-6}", &repo).unwrap_err().to_string(),
+        parse_spec("@{-6}", &repo).unwrap_err().probable_cause().to_string(),
         "HEAD has 5 prior checkouts and checkout number 6 is out of range"
     );
 }
@@ -32,7 +32,7 @@ fn by_index_unborn_head() {
     let repo = &repo("new").unwrap();
 
     assert_eq!(
-        parse_spec("@{1}", repo).unwrap_err().to_string(),
+        parse_spec("@{1}", repo).unwrap_err().probable_cause().to_string(),
         "Unborn heads do not have a reflog yet"
     );
 }
@@ -69,8 +69,11 @@ fn by_index() {
     }
 
     assert_eq!(
-        parse_spec("main@{12345}", repo).unwrap_err().to_string(),
-        "Reference \"refs/heads/main\" has 4 ref-log entries and entry number 12345 is out of range"
+        parse_spec("main@{12345}", repo)
+            .unwrap_err()
+            .probable_cause()
+            .to_string(),
+        "Reference 'refs/heads/main' has 4 ref-log entries and entry number 12345 is out of range"
     );
 }
 
diff --git a/gix/tests/gix/revision/spec/from_bytes/regex.rs b/gix/tests/gix/revision/spec/from_bytes/regex.rs
index fe7b4a5446d..238562b7504 100644
--- a/gix/tests/gix/revision/spec/from_bytes/regex.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/regex.rs
@@ -20,8 +20,14 @@ mod with_known_revision {
         assert_eq!(parse_spec("0000000000^{/x}", &repo).unwrap(), expected);
         assert_eq!(parse_spec("@^{/x}", &repo).unwrap(), expected, "ref names are resolved");
 
+        let err = parse_spec_no_baseline("@^{/.*x}", &repo).unwrap_err();
+        insta::assert_debug_snapshot!(err, @r#"
+        Delegate couldn't find '.*x' (negated: false)
+        |
+        └─ None of 1 commits from 0000000000e matched text ".*x"
+        "#);
         assert_eq!(
-            parse_spec_no_baseline("@^{/.*x}", &repo).unwrap_err().to_string(),
+            err.probable_cause().to_string(),
             "None of 1 commits from 0000000000e matched text \".*x\"",
             "regexes are not actually available for us, but git could do that"
         );
@@ -49,8 +55,14 @@ mod with_known_revision {
             expected,
             "we can use real regexes here"
         );
+        let err = parse_spec_no_baseline("@^{/^x}", &repo).unwrap_err();
+        insta::assert_debug_snapshot!(err, @r#"
+        Delegate couldn't find '^x' (negated: false)
+        |
+        └─ None of 1 commits from 0000000000e matched regex "^x"
+        "#);
         assert_eq!(
-            parse_spec_no_baseline("@^{/^x}", &repo).unwrap_err().to_string(),
+            err.probable_cause().to_string(),
             "None of 1 commits from 0000000000e matched regex \"^x\"",
         );
     }
@@ -83,8 +95,14 @@ mod find_youngest_matching_commit {
             Spec::from_id(hex_to_id("55e825ebe8fd2ff78cad3826afb696b96b576a7e").attach(&repo))
         );
 
+        let err = parse_spec_no_baseline(":/messa.e", &repo).unwrap_err();
+        insta::assert_debug_snapshot!(err, @r#"
+        Delegate couldn't find 'messa.e' (negated: false)
+        |
+        └─ None of 10 commits reached from all references matched text "messa.e"
+        "#);
         assert_eq!(
-            parse_spec_no_baseline(":/messa.e", &repo).unwrap_err().to_string(),
+            err.probable_cause().to_string(),
             "None of 10 commits reached from all references matched text \"messa.e\"",
             "regex definitely don't work as it's not compiled in"
         );
@@ -100,8 +118,14 @@ mod find_youngest_matching_commit {
             Spec::from_id(hex_to_id("ef80b4b77b167f326351c93284dc0eb00dd54ff4").attach(&repo))
         );
 
+        let err = parse_spec(":/not there", &repo).unwrap_err();
+        insta::assert_debug_snapshot!(err, @r#"
+        Delegate couldn't find 'not there' (negated: false)
+        |
+        └─ None of 10 commits reached from all references matched regex "not there"
+        "#);
         assert_eq!(
-            parse_spec(":/not there", &repo).unwrap_err().to_string(),
+            err.probable_cause().to_string(),
             "None of 10 commits reached from all references matched regex \"not there\""
         );
 
diff --git a/gix/tests/gix/revision/spec/from_bytes/traverse.rs b/gix/tests/gix/revision/spec/from_bytes/traverse.rs
index 8a28b4da79e..0232cae0a55 100644
--- a/gix/tests/gix/revision/spec/from_bytes/traverse.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/traverse.rs
@@ -26,16 +26,22 @@ fn freestanding_negation_yields_descriptive_error() -> crate::Result {
     let repo = repo("complex_graph")?;
     for revspec in ["^^", "^^HEAD"] {
         assert_eq!(
-            parse_spec(revspec, &repo).unwrap_err().to_string(),
+            parse_spec(revspec, &repo).unwrap_err().probable_cause().to_string(),
             "Tried to navigate the commit-graph without providing an anchor first"
         );
     }
     assert_eq!(
-        parse_spec("^", &repo).unwrap_err().to_string(),
+        parse_spec("^", &repo).unwrap_err().probable_cause().to_string(),
         "The rev-spec is malformed and misses a ref name"
     );
+    let err = parse_spec("^!", &repo).unwrap_err();
+    insta::assert_debug_snapshot!(err, @r#"
+    couldn't parse revision: !
+    |
+    └─ The ref partially named "!" could not be found
+    "#);
     assert_eq!(
-        parse_spec("^!", &repo).unwrap_err().to_string(),
+        err.probable_cause().to_string(),
         "The ref partially named \"!\" could not be found"
     );
     Ok(())
@@ -60,7 +66,7 @@ fn parent() {
     );
     assert_eq!(parse_spec("a", &repo).unwrap(), parse_spec("a^0", &repo).unwrap());
     assert_eq!(
-        parse_spec("a^42", &repo).unwrap_err().to_string(),
+        parse_spec("a^42", &repo).unwrap_err().probable_cause().to_string(),
         "Commit 55e825e has 2 parents and parent number 42 is out of range"
     );
 }
@@ -78,7 +84,7 @@ fn ancestors() {
         Spec::from_id(hex_to_id("9f9eac6bd1cd4b4cc6a494f044b28c985a22972b").attach(&repo))
     );
     assert_eq!(
-        parse_spec("a~42", &repo).unwrap_err().to_string(),
+        parse_spec("a~42", &repo).unwrap_err().probable_cause().to_string(),
         "Commit 55e825e has 3 ancestors along the first parent and ancestor number 42 is out of range"
     );
 }
diff --git a/gix/tests/gix/revision/spec/from_bytes/util.rs b/gix/tests/gix/revision/spec/from_bytes/util.rs
index 934df1f20f4..2f803cf3cf7 100644
--- a/gix/tests/gix/revision/spec/from_bytes/util.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/util.rs
@@ -115,7 +115,7 @@ static BASELINE: LazyLock<HashMap<PathBuf, HashMap<BString, Option<gix_revision:
 pub fn parse_spec_no_baseline<'a>(
     spec: &str,
     repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
+) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
     parse_spec_no_baseline_opts(spec, repo, Default::default())
 }
 
@@ -130,7 +130,7 @@ enum BaselineExpectation {
 pub fn parse_spec_better_than_baseline<'a>(
     spec: &str,
     repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
+) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = gix::revision::Spec::from_bstr(spec, repo, Default::default());
     compare_with_baseline(&res, repo, spec, BaselineExpectation::GitFailsWeSucceed);
     res
@@ -140,7 +140,7 @@ pub fn parse_spec_no_baseline_opts<'a>(
     spec: &str,
     repo: &'a gix::Repository,
     opts: gix::revision::spec::parse::Options,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
+) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
     gix::revision::Spec::from_bstr(spec, repo, opts)
 }
 
@@ -148,23 +148,20 @@ pub fn parse_spec_opts<'a>(
     spec: &str,
     repo: &'a gix::Repository,
     opts: gix::revision::spec::parse::Options,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
+) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = gix::revision::Spec::from_bstr(spec, repo, opts);
     compare_with_baseline(&res, repo, spec, BaselineExpectation::Same);
     res
 }
 
-pub fn rev_parse<'a>(
-    spec: &str,
-    repo: &'a gix::Repository,
-) -> Result<gix::revision::Spec<'a>, gix::revision::spec::parse::Error> {
+pub fn rev_parse<'a>(spec: &str, repo: &'a gix::Repository) -> Result<gix::revision::Spec<'a>, gix_error::Error> {
     let res = repo.rev_parse(spec);
     compare_with_baseline(&res, repo, spec, BaselineExpectation::Same);
     res
 }
 
 fn compare_with_baseline(
-    res: &Result<gix::revision::Spec<'_>, gix::revision::spec::parse::Error>,
+    res: &Result<gix::revision::Spec<'_>, gix_error::Error>,
     repo: &gix::Repository,
     spec: &str,
     expectation: BaselineExpectation,
@@ -189,10 +186,7 @@ fn compare_with_baseline(
     }
 }
 
-pub fn parse_spec(
-    spec: impl AsRef<str>,
-    repo: &gix::Repository,
-) -> Result<gix::revision::Spec<'_>, gix::revision::spec::parse::Error> {
+pub fn parse_spec(spec: impl AsRef<str>, repo: &gix::Repository) -> Result<gix::revision::Spec<'_>, gix_error::Error> {
     parse_spec_opts(spec.as_ref(), repo, Default::default())
 }
 
diff --git a/gix/tests/submodule_open.rs b/gix/tests/submodule_open.rs
index f1a6970fe76..e7c25219c37 100644
--- a/gix/tests/submodule_open.rs
+++ b/gix/tests/submodule_open.rs
@@ -39,6 +39,7 @@ fn on_nested_symlink() -> gix_testtools::Result {
     Ok(())
 }
 
+#[cfg(feature = "status")]
 fn p(path: &str) -> &std::path::Path {
     std::path::Path::new(path)
 }
diff --git a/src/shared.rs b/src/shared.rs
index b38f9248aa4..4b103a20f05 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -391,7 +391,7 @@ mod clap {
 
         fn parse_ref(&self, cmd: &Command, arg: Option<&Arg>, value: &OsStr) -> Result<Self::Value, Error> {
             StringValueParser::new()
-                .try_map(|arg| gix::date::parse(&arg, Some(std::time::SystemTime::now())))
+                .try_map(|arg| gix::date::parse(&arg, Some(std::time::SystemTime::now())).map_err(gix::Exn::into_box))
                 .parse_ref(cmd, arg, value)
         }
     }
diff --git a/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure b/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
index 8a6045c0553..83ea487db32 100644
--- a/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
+++ b/tests/snapshots/porcelain/estimate-hours/invalid-branch-name-failure
@@ -1 +1,4 @@
-Error: The ref partially named "foobar" could not be found
\ No newline at end of file
+Error: couldn't parse revision: foobar
+
+Caused by:
+    The ref partially named "foobar" could not be found
\ No newline at end of file