@@ -21,6 +21,8 @@ ccusage monthly --since 20260101
 ccusage session --until 20260531
 ```
 
+Both bounds accept `YYYY-MM-DD` or `YYYYMMDD` and are inclusive. Any other spelling, or a value that is not a real calendar date such as `2026-02-30`, is rejected with a non-zero exit code instead of silently changing which rows the report keeps. The same check applies to `since` and `until` in a [configuration file](/guide/config-files).
+
 ### Recent Periods
 
 Instead of working out dates, ask for the most recent periods of whatever the report groups by:
 
@@ -4,8 +4,9 @@ use crate::arg_parser::ArgParser;
 use crate::help::{print_help_and_exit, print_version_and_exit};
 use ccusage_cli::{
     AgentCommandArgs, AgentReportKind, BlocksArgs, CliConfig, CodexSpeed, Command, CostMode,
-    CostSource, DailyArgs, OPENCODE_AGENT_REPORTS, STANDARD_AGENT_REPORTS, SessionArgs, SharedArgs,
-    SortOrder, StatuslineArgs, VisualBurnRate, WeekDay, WeeklyArgs, normalize_date_bound,
+    CostSource, DATE_BOUND_FORMATS, DailyArgs, OPENCODE_AGENT_REPORTS, STANDARD_AGENT_REPORTS,
+    SessionArgs, SharedArgs, SortOrder, StatuslineArgs, VisualBurnRate, WeekDay, WeeklyArgs,
+    normalize_date_bound,
 };
 
 use crate::Cli;
@@ -713,10 +714,10 @@ fn parse_shared_arg_for_command(
 fn parse_shared_arg(parser: &mut ArgParser, shared: &mut SharedArgs) -> Result<(), String> {
     match parser.next_flag()?.as_str() {
         "-s" | "--since" => {
-            shared.since = Some(normalize_date_bound(&parser.value_for("--since")?))
+            shared.since = Some(parse_date_bound("--since", &parser.value_for("--since")?)?)
         }
         "-u" | "--until" => {
-            shared.until = Some(normalize_date_bound(&parser.value_for("--until")?))
+            shared.until = Some(parse_date_bound("--until", &parser.value_for("--until")?)?)
         }
         "--last" => shared.last = Some(parse_last_periods(&parser.value_for("--last")?)?),
         "-j" | "--json" => shared.json = true,
@@ -1005,6 +1006,12 @@ fn is_shared_flag(arg: &str) -> bool {
     )
 }
 
+fn parse_date_bound(flag: &str, value: &str) -> Result<String, String> {
+    normalize_date_bound(value).ok_or_else(|| {
+        format!("Invalid value for {flag} '{value}'. Expected {DATE_BOUND_FORMATS}.")
+    })
+}
+
 fn parse_last_periods(value: &str) -> Result<u32, String> {
     match value.parse() {
         Ok(0) | Err(_) => Err(format!(
 
@@ -242,6 +242,38 @@ fn commandless_invocation_preserves_default_dispatch() {
     assert!(cli.command.is_none());
 }
 
+#[test]
+fn rejects_date_bounds_that_are_not_real_calendar_dates() {
+    for value in [
+        "2026-02-30",
+        "2026-13-01",
+        "abc",
+        "2026/07/10",
+        "2026-07-10T00:00:00Z",
+    ] {
+        assert_eq!(
+            parse_error(&["ccusage", "daily", "--since", value]),
+            format!("Invalid value for --since '{value}'. Expected YYYY-MM-DD or YYYYMMDD.")
+        );
+        assert_eq!(
+            parse_error(&["ccusage", "daily", "--until", value]),
+            format!("Invalid value for --until '{value}'. Expected YYYY-MM-DD or YYYYMMDD.")
+        );
+    }
+}
+
+#[test]
+fn accepts_both_documented_date_bound_formats() {
+    for (value, normalized) in [("2026-07-10", "20260710"), ("20260710", "20260710")] {
+        let cli = parse(&["ccusage", "daily", "--since", value, "--until", value]);
+        let Some(Command::All(args)) = cli.command else {
+            panic!("expected all-agent command");
+        };
+        assert_eq!(args.shared.since.as_deref(), Some(normalized));
+        assert_eq!(args.shared.until.as_deref(), Some(normalized));
+    }
+}
+
 #[test]
 fn parses_last_periods_on_period_reports() {
     let cli = parse(&["ccusage", "daily", "--last", "1"]);
 
@@ -18,6 +18,7 @@ renderer, and the help JSON live in `ccusage-cli-parser` instead.
 - `types::Command`
 - `types::CostMode`
 - `types::CostSource`
+- `types::DATE_BOUND_FORMATS`
 - `types::DailyArgs`
 - `types::NamedPiStore`
 - `types::NoConfig`
 
@@ -2,7 +2,7 @@ mod types;
 
 pub use types::{
     AgentCommandArgs, AgentReportKind, BlocksArgs, CliConfig, CodexSpeed, Command, CostMode,
-    CostSource, DailyArgs, NamedPiStore, NoConfig, OPENCODE_AGENT_REPORTS, PricingOverride,
-    STANDARD_AGENT_REPORTS, SessionArgs, SharedArgs, SortOrder, StatuslineArgs, VisualBurnRate,
-    WeekDay, WeeklyArgs, normalize_date_bound,
+    CostSource, DATE_BOUND_FORMATS, DailyArgs, NamedPiStore, NoConfig, OPENCODE_AGENT_REPORTS,
+    PricingOverride, STANDARD_AGENT_REPORTS, SessionArgs, SharedArgs, SortOrder, StatuslineArgs,
+    VisualBurnRate, WeekDay, WeeklyArgs, normalize_date_bound,
 };
@@ -66,8 +66,57 @@ impl SharedArgs {
     }
 }
 
-pub fn normalize_date_bound(value: &str) -> String {
-    value.replace('-', "")
+/// The two documented spellings of a `--since` / `--until` bound.
+pub const DATE_BOUND_FORMATS: &str = "YYYY-MM-DD or YYYYMMDD";
+
+/// Normalizes a date bound into the `YYYYMMDD` form the report keys use.
+///
+/// Reports compare bounds against row keys as plain strings, so a value that is
+/// not one of the two documented formats, or that is not a real calendar date,
+/// would silently turn the filter into a no-op or drop every row. Returns
+/// `None` for those values so callers can reject them.
+pub fn normalize_date_bound(value: &str) -> Option<String> {
+    let bytes = value.as_bytes();
+    let digits: [u8; 8] = match bytes.len() {
+        8 => bytes.try_into().ok()?,
+        10 if bytes[4] == b'-' && bytes[7] == b'-' => {
+            let mut digits = [0u8; 8];
+            digits[..4].copy_from_slice(&bytes[..4]);
+            digits[4..6].copy_from_slice(&bytes[5..7]);
+            digits[6..].copy_from_slice(&bytes[8..]);
+            digits
+        }
+        _ => return None,
+    };
+    if !digits.iter().all(u8::is_ascii_digit) {
+        return None;
+    }
+    let number = |slice: &[u8]| {
+        slice
+            .iter()
+            .fold(0u32, |value, digit| value * 10 + u32::from(digit - b'0'))
+    };
+    let year = number(&digits[..4]) as i32;
+    let month = number(&digits[4..6]);
+    let day = number(&digits[6..]);
+    if day == 0 || day > days_in_month(year, month) {
+        return None;
+    }
+    std::str::from_utf8(&digits).ok().map(str::to_string)
+}
+
+fn days_in_month(year: i32, month: u32) -> u32 {
+    match month {
+        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+        4 | 6 | 9 | 11 => 30,
+        2 if is_leap_year(year) => 29,
+        2 => 28,
+        _ => 0,
+    }
+}
+
+fn is_leap_year(year: i32) -> bool {
+    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
 }
 
 #[derive(Clone)]
@@ -265,3 +314,60 @@ pub trait CliConfig {
 pub struct NoConfig;
 
 impl CliConfig for NoConfig {}
+
+#[cfg(test)]
+mod tests {
+    use super::normalize_date_bound;
+
+    #[test]
+    fn accepts_both_documented_formats() {
+        assert_eq!(
+            normalize_date_bound("2026-07-10").as_deref(),
+            Some("20260710")
+        );
+        assert_eq!(
+            normalize_date_bound("20260710").as_deref(),
+            Some("20260710")
+        );
+    }
+
+    #[test]
+    fn accepts_leap_day_only_in_leap_years() {
+        assert_eq!(
+            normalize_date_bound("2024-02-29").as_deref(),
+            Some("20240229")
+        );
+        assert_eq!(
+            normalize_date_bound("2000-02-29").as_deref(),
+            Some("20000229")
+        );
+        assert_eq!(normalize_date_bound("2026-02-29"), None);
+        assert_eq!(normalize_date_bound("1900-02-29"), None);
+    }
+
+    #[test]
+    fn rejects_impossible_calendar_dates() {
+        assert_eq!(normalize_date_bound("2026-02-30"), None);
+        assert_eq!(normalize_date_bound("2026-13-01"), None);
+        assert_eq!(normalize_date_bound("2026-00-10"), None);
+        assert_eq!(normalize_date_bound("2026-07-00"), None);
+        assert_eq!(normalize_date_bound("2026-04-31"), None);
+    }
+
+    #[test]
+    fn rejects_undocumented_spellings() {
+        assert_eq!(normalize_date_bound("abc"), None);
+        assert_eq!(normalize_date_bound(""), None);
+        assert_eq!(normalize_date_bound("2026/07/10"), None);
+        assert_eq!(normalize_date_bound("2026-7-10"), None);
+        assert_eq!(normalize_date_bound("2026-07-10T00:00:00Z"), None);
+        assert_eq!(normalize_date_bound("2026-07-1"), None);
+        assert_eq!(normalize_date_bound("2026_07_10"), None);
+    }
+
+    #[test]
+    fn rejects_non_ascii_values_without_panicking() {
+        assert_eq!(normalize_date_bound("２０２６０７１０"), None);
+        assert_eq!(normalize_date_bound("2026-07-1０"), None);
+    }
+}