`adeab44`

Add reminder notification daemon

Authored by

espadonne 2 weeks ago

SHA: adeab446f350a29061aeeb3596e7b14613273313
Parents: b2c7109
Tree: a32f3d2

7 changed files

Status	File	+	-
M	`Cargo.lock`	767	3
M	`Cargo.toml`	3	0
M	`README.md`	8	2
M	`src/cli.rs`	361	1
M	`src/lib.rs`	2	0
A	`src/reminders.rs`	762	0
A	`src/services.rs`	564	0

Cargo.lockmodified

  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 +[[package]]
 +name = "async-broadcast"
 +version = "0.7.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
 +dependencies = [
 + "event-listener",
 + "event-listener-strategy",
 + "futures-core",
 + "pin-project-lite",
 +]
++
 +[[package]]
 +name = "async-channel"
 +version = "2.5.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 +dependencies = [
 + "concurrent-queue",
 + "event-listener-strategy",
 + "futures-core",
 + "pin-project-lite",
 +]
++
 +[[package]]
 +name = "async-executor"
 +version = "1.14.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
 +dependencies = [
 + "async-task",
 + "concurrent-queue",
 + "fastrand",
 + "futures-lite",
 + "pin-project-lite",
 + "slab",
 +]
++
 +[[package]]
 +name = "async-io"
 +version = "2.6.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 +dependencies = [
 + "autocfg",
 + "cfg-if",
 + "concurrent-queue",
 + "futures-io",
 + "futures-lite",
 + "parking",
 + "polling",
 + "rustix",
 + "slab",
 + "windows-sys 0.61.2",
 +]
++
 +[[package]]
 +name = "async-lock"
 +version = "3.4.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 +dependencies = [
 + "event-listener",
 + "event-listener-strategy",
 + "pin-project-lite",
 +]
++
 +[[package]]
 +name = "async-process"
 +version = "2.5.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
 +dependencies = [
 + "async-channel",
 + "async-io",
 + "async-lock",
 + "async-signal",
 + "async-task",
 + "blocking",
 + "cfg-if",
 + "event-listener",
 + "futures-lite",
 + "rustix",
 +]
++
 +[[package]]
 +name = "async-recursion"
 +version = "1.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
 +[[package]]
 +name = "async-signal"
 +version = "0.2.14"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"
 +dependencies = [
 + "async-io",
 + "async-lock",
 + "atomic-waker",
 + "cfg-if",
 + "futures-core",
 + "futures-io",
 + "rustix",
 + "signal-hook-registry",
 + "slab",
 + "windows-sys 0.61.2",
 +]
++
 +[[package]]
 +name = "async-task"
 +version = "4.7.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
++
 +[[package]]
 +name = "async-trait"
 +version = "0.1.89"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
  [[package]]
  name = "atomic"
  version = "0.6.1"
   "generic-array",
+ ]
 +[[package]]
 +name = "block2"
 +version = "0.6.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
 +dependencies = [
 + "objc2",
 +]
++
 +[[package]]
 +name = "blocking"
 +version = "1.6.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
 +dependencies = [
 + "async-channel",
 + "async-task",
 + "futures-io",
 + "futures-lite",
 + "piper",
 +]
++
  [[package]]
  name = "bumpalo"
  version = "3.20.2"
   "static_assertions",
+ ]
 +[[package]]
 +name = "concurrent-queue"
 +version = "2.5.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 +dependencies = [
 + "crossbeam-utils",
 +]
++
  [[package]]
  name = "convert_case"
  version = "0.10.0"
   "libc",
+ ]
 +[[package]]
 +name = "crossbeam-utils"
 +version = "0.8.21"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
++
  [[package]]
  name = "crossterm"
  version = "0.29.0"
   "crypto-common",
+ ]
 +[[package]]
 +name = "directories"
 +version = "6.0.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
 +dependencies = [
 + "dirs-sys",
 +]
++
 +[[package]]
 +name = "dirs-sys"
 +version = "0.5.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
 +dependencies = [
 + "libc",
 + "option-ext",
 + "redox_users",
 + "windows-sys 0.61.2",
 +]
++
 +[[package]]
 +name = "dispatch2"
 +version = "0.3.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
 +dependencies = [
 + "bitflags 2.11.1",
 + "objc2",
 +]
++
  [[package]]
  name = "displaydoc"
  version = "0.2.5"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 +[[package]]
 +name = "endi"
 +version = "1.1.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
++
 +[[package]]
 +name = "enumflags2"
 +version = "0.7.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
 +dependencies = [
 + "enumflags2_derive",
 + "serde",
 +]
++
 +[[package]]
 +name = "enumflags2_derive"
 +version = "0.7.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
  [[package]]
  name = "equivalent"
  version = "1.0.2"
   "num-traits",
+ ]
 +[[package]]
 +name = "event-listener"
 +version = "5.4.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
 +dependencies = [
 + "concurrent-queue",
 + "parking",
 + "pin-project-lite",
 +]
++
 +[[package]]
 +name = "event-listener-strategy"
 +version = "0.5.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
 +dependencies = [
 + "event-listener",
 + "pin-project-lite",
 +]
++
  [[package]]
  name = "fancy-regex"
  version = "0.11.0"
   "regex",
+ ]
 +[[package]]
 +name = "fastrand"
 +version = "2.4.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
++
  [[package]]
  name = "filedescriptor"
  version = "0.8.3"
   "percent-encoding",
+ ]
 +[[package]]
 +name = "fs2"
 +version = "0.4.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
 +dependencies = [
 + "libc",
 + "winapi",
 +]
++
  [[package]]
  name = "futures-channel"
  version = "0.3.32"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 +[[package]]
 +name = "futures-lite"
 +version = "2.6.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
 +dependencies = [
 + "fastrand",
 + "futures-core",
 + "futures-io",
 + "parking",
 + "pin-project-lite",
 +]
++
  [[package]]
  name = "futures-sink"
  version = "0.3.32"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 +[[package]]
 +name = "hermit-abi"
 +version = "0.5.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
++
  [[package]]
  name = "hex"
  version = "0.4.3"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"
 +[[package]]
 +name = "libredox"
 +version = "0.1.16"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
 +dependencies = [
 + "libc",
 +]
++
  [[package]]
  name = "line-clipping"
  version = "0.3.7"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
 +[[package]]
 +name = "mac-notification-sys"
 +version = "0.6.12"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "29a16783dd1a47849b8c8133c9cd3eb2112cfbc6901670af3dba47c8bbfb07d3"
 +dependencies = [
 + "cc",
 + "objc2",
 + "objc2-foundation",
 + "time",
 +]
++
  [[package]]
  name = "mac_address"
  version = "1.1.8"
   "minimal-lexical",
+ ]
 +[[package]]
 +name = "notify-rust"
 +version = "4.16.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5e551a9f0db223eaf3eb156906f99f46897fd951ee66dd1cb0be14db4d36d2fa"
 +dependencies = [
 + "futures-lite",
 + "log",
 + "mac-notification-sys",
 + "serde",
 + "tauri-winrt-notification",
 + "zbus",
 +]
++
  [[package]]
  name = "num-conv"
  version = "0.2.1"
   "libc",
+ ]
 +[[package]]
 +name = "objc2"
 +version = "0.6.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
 +dependencies = [
 + "objc2-encode",
 +]
++
 +[[package]]
 +name = "objc2-core-foundation"
 +version = "0.3.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 +dependencies = [
 + "bitflags 2.11.1",
 + "dispatch2",
 + "objc2",
 +]
++
 +[[package]]
 +name = "objc2-encode"
 +version = "4.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
++
 +[[package]]
 +name = "objc2-foundation"
 +version = "0.3.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
 +dependencies = [
 + "bitflags 2.11.1",
 + "block2",
 + "libc",
 + "objc2",
 + "objc2-core-foundation",
 +]
++
  [[package]]
  name = "once_cell"
  version = "1.21.4"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 +[[package]]
 +name = "option-ext"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
++
  [[package]]
  name = "ordered-float"
  version = "4.6.0"
   "num-traits",
+ ]
 +[[package]]
 +name = "ordered-stream"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
 +dependencies = [
 + "futures-core",
 + "pin-project-lite",
 +]
++
 +[[package]]
 +name = "parking"
 +version = "2.2.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
++
  [[package]]
  name = "parking_lot"
  version = "0.12.5"
   "libc",
   "redox_syscall",
   "smallvec",
 - "windows-link",
 + "windows-link 0.2.1",
+ ]
  [[package]]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 +[[package]]
 +name = "piper"
 +version = "0.2.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
 +dependencies = [
 + "atomic-waker",
 + "fastrand",
 + "futures-io",
 +]
++
 +[[package]]
 +name = "polling"
 +version = "3.11.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
 +dependencies = [
 + "cfg-if",
 + "concurrent-queue",
 + "hermit-abi",
 + "pin-project-lite",
 + "rustix",
 + "windows-sys 0.61.2",
 +]
++
  [[package]]
  name = "portable-atomic"
  version = "1.13.1"
   "syn 2.0.117",
+ ]
 +[[package]]
 +name = "proc-macro-crate"
 +version = "3.5.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
 +dependencies = [
 + "toml_edit",
 +]
++
  [[package]]
  name = "proc-macro2"
  version = "1.0.106"
   "unicode-ident",
+ ]
 +[[package]]
 +name = "quick-xml"
 +version = "0.37.5"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
 +dependencies = [
 + "memchr",
 +]
++
  [[package]]
  name = "quinn"
  version = "0.11.9"
  version = "0.1.0"
  dependencies = [
   "crossterm",
 + "directories",
 + "fs2",
 + "notify-rust",
   "ratatui",
   "reqwest",
   "serde",
   "bitflags 2.11.1",
+ ]
 +[[package]]
 +name = "redox_users"
 +version = "0.5.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
 +dependencies = [
 + "getrandom 0.2.17",
 + "libredox",
 + "thiserror 2.0.18",
 +]
++
  [[package]]
  name = "regex"
  version = "1.12.3"
   "zmij",
+ ]
 +[[package]]
 +name = "serde_repr"
 +version = "0.1.20"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
  [[package]]
  name = "serde_urlencoded"
  version = "0.7.1"
   "syn 2.0.117",
+ ]
 +[[package]]
 +name = "tauri-winrt-notification"
 +version = "0.7.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0b1e66e07de489fe43a46678dd0b8df65e0c973909df1b60ba33874e297ba9b9"
 +dependencies = [
 + "quick-xml",
 + "thiserror 2.0.18",
 + "windows",
 + "windows-version",
 +]
++
 +[[package]]
 +name = "tempfile"
 +version = "3.27.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 +dependencies = [
 + "fastrand",
 + "getrandom 0.4.2",
 + "once_cell",
 + "rustix",
 + "windows-sys 0.61.2",
 +]
++
  [[package]]
  name = "terminfo"
  version = "0.9.0"
   "tokio",
+ ]
 +[[package]]
 +name = "toml_datetime"
 +version = "1.1.1+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
 +dependencies = [
 + "serde_core",
 +]
++
 +[[package]]
 +name = "toml_edit"
 +version = "0.25.11+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
 +dependencies = [
 + "indexmap",
 + "toml_datetime",
 + "toml_parser",
 + "winnow 1.0.2",
 +]
++
 +[[package]]
 +name = "toml_parser"
 +version = "1.1.2+spec-1.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 +dependencies = [
 + "winnow 1.0.2",
 +]
++
  [[package]]
  name = "tower"
  version = "0.5.3"
  checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
  dependencies = [
   "pin-project-lite",
 + "tracing-attributes",
   "tracing-core",
+ ]
 +[[package]]
 +name = "tracing-attributes"
 +version = "0.1.31"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
  [[package]]
  name = "tracing-core"
  version = "0.1.36"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 +[[package]]
 +name = "uds_windows"
 +version = "1.2.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
 +dependencies = [
 + "memoffset",
 + "tempfile",
 + "windows-sys 0.61.2",
 +]
++
  [[package]]
  name = "unicode-ident"
  version = "1.0.24"
   "atomic",
   "getrandom 0.4.2",
   "js-sys",
 + "serde_core",
   "wasm-bindgen",
+ ]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 +[[package]]
 +name = "windows"
 +version = "0.61.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
 +dependencies = [
 + "windows-collections",
 + "windows-core",
 + "windows-future",
 + "windows-link 0.1.3",
 + "windows-numerics",
 +]
++
 +[[package]]
 +name = "windows-collections"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 +dependencies = [
 + "windows-core",
 +]
++
 +[[package]]
 +name = "windows-core"
 +version = "0.61.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 +dependencies = [
 + "windows-implement",
 + "windows-interface",
 + "windows-link 0.1.3",
 + "windows-result",
 + "windows-strings",
 +]
++
 +[[package]]
 +name = "windows-future"
 +version = "0.2.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
 +dependencies = [
 + "windows-core",
 + "windows-link 0.1.3",
 + "windows-threading",
 +]
++
 +[[package]]
 +name = "windows-implement"
 +version = "0.60.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
 +[[package]]
 +name = "windows-interface"
 +version = "0.59.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 +]
++
 +[[package]]
 +name = "windows-link"
 +version = "0.1.3"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
++
  [[package]]
  name = "windows-link"
  version = "0.2.1"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 +[[package]]
 +name = "windows-numerics"
 +version = "0.2.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
 +dependencies = [
 + "windows-core",
 + "windows-link 0.1.3",
 +]
++
 +[[package]]
 +name = "windows-result"
 +version = "0.3.4"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
 +dependencies = [
 + "windows-link 0.1.3",
 +]
++
 +[[package]]
 +name = "windows-strings"
 +version = "0.4.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 +dependencies = [
 + "windows-link 0.1.3",
 +]
++
  [[package]]
  name = "windows-sys"
  version = "0.52.0"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
  dependencies = [
 - "windows-link",
 + "windows-link 0.2.1",
+ ]
  [[package]]
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
  dependencies = [
 - "windows-link",
 + "windows-link 0.2.1",
   "windows_aarch64_gnullvm 0.53.1",
   "windows_aarch64_msvc 0.53.1",
   "windows_i686_gnu 0.53.1",
   "windows_x86_64_msvc 0.53.1",
+ ]
 +[[package]]
 +name = "windows-threading"
 +version = "0.1.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
 +dependencies = [
 + "windows-link 0.1.3",
 +]
++
 +[[package]]
 +name = "windows-version"
 +version = "0.1.7"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
 +dependencies = [
 + "windows-link 0.2.1",
 +]
++
  [[package]]
  name = "windows_aarch64_gnullvm"
  version = "0.52.6"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 +[[package]]
 +name = "winnow"
 +version = "0.7.15"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 +dependencies = [
 + "memchr",
 +]
++
 +[[package]]
 +name = "winnow"
 +version = "1.0.2"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
 +dependencies = [
 + "memchr",
 +]
++
  [[package]]
  name = "wit-bindgen"
  version = "0.51.0"
   "synstructure",
+ ]
 +[[package]]
 +name = "zbus"
 +version = "5.14.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ca82f95dbd3943a40a53cfded6c2d0a2ca26192011846a1810c4256ef92c60bc"
 +dependencies = [
 + "async-broadcast",
 + "async-executor",
 + "async-io",
 + "async-lock",
 + "async-process",
 + "async-recursion",
 + "async-task",
 + "async-trait",
 + "blocking",
 + "enumflags2",
 + "event-listener",
 + "futures-core",
 + "futures-lite",
 + "hex",
 + "libc",
 + "ordered-stream",
 + "rustix",
 + "serde",
 + "serde_repr",
 + "tracing",
 + "uds_windows",
 + "uuid",
 + "windows-sys 0.61.2",
 + "winnow 0.7.15",
 + "zbus_macros",
 + "zbus_names",
 + "zvariant",
 +]
++
 +[[package]]
 +name = "zbus_macros"
 +version = "5.14.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "897e79616e84aac4b2c46e9132a4f63b93105d54fe8c0e8f6bffc21fa8d49222"
 +dependencies = [
 + "proc-macro-crate",
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 + "zbus_names",
 + "zvariant",
 + "zvariant_utils",
 +]
++
 +[[package]]
 +name = "zbus_names"
 +version = "4.3.1"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "ffd8af6d5b78619bab301ff3c560a5bd22426150253db278f164d6cf3b72c50f"
 +dependencies = [
 + "serde",
 + "winnow 0.7.15",
 + "zvariant",
 +]
++
  [[package]]
  name = "zerocopy"
  version = "0.8.48"
  version = "1.0.21"
  source = "registry+https://github.com/rust-lang/crates.io-index"
  checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
++
 +[[package]]
 +name = "zvariant"
 +version = "5.10.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5708299b21903bbe348e94729f22c49c55d04720a004aa350f1f9c122fd2540b"
 +dependencies = [
 + "endi",
 + "enumflags2",
 + "serde",
 + "winnow 0.7.15",
 + "zvariant_derive",
 + "zvariant_utils",
 +]
++
 +[[package]]
 +name = "zvariant_derive"
 +version = "5.10.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "5b59b012ebe9c46656f9cc08d8da8b4c726510aef12559da3e5f1bf72780752c"
 +dependencies = [
 + "proc-macro-crate",
 + "proc-macro2",
 + "quote",
 + "syn 2.0.117",
 + "zvariant_utils",
 +]
++
 +[[package]]
 +name = "zvariant_utils"
 +version = "3.3.0"
 +source = "registry+https://github.com/rust-lang/crates.io-index"
 +checksum = "f75c23a64ef8f40f13a6989991e643554d9bef1d682a281160cf0c1bc389c5e9"
 +dependencies = [
 + "proc-macro2",
 + "quote",
 + "serde",
 + "syn 2.0.117",
 + "winnow 0.7.15",
 +]

Cargo.tomlmodified

  [dependencies]
  crossterm = "0.29.0"
 +directories = "6.0.0"
 +fs2 = "0.4.3"
 +notify-rust = "4"
  ratatui = "0.30.0"
  reqwest = { version = "0.12.24", default-features = false, features = ["blocking", "rustls-tls"] }
  serde = { version = "1.0.228", features = ["derive"] }

README.mdmodified

  ```sh
  rcal [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]
 +rcal reminders run [--events-file PATH] [--state-file PATH] [--once]
 +rcal reminders install [--events-file PATH]
 +rcal reminders uninstall
 +rcal reminders status
 +rcal reminders test
  ```
  Options:
  Created events are stored locally as JSON and are shown immediately in month,
  week, and day views. The create/edit modal supports timed events, single-day
  all-day events, recurrence, location, notes, and multiple reminder offsets.
 -Reminder notifications are not delivered yet.
 +Reminder notifications are delivered by a user-level background service. Use
 +`rcal reminders install` to install it, `rcal reminders status` to inspect it,
 +and `rcal reminders test` to send a test notification.
  ## Layout
  - Real account integrations for Outlook, Google Calendar, Exchange, and similar
    providers are not implemented yet.
 -- Reminder offsets are stored but do not trigger notifications yet.
  - Packaging is currently source-based through Cargo.
  ## Development

src/cli.rsmodified

          KeyboardInput, MouseInput, RecurrenceChoiceInputResult,
      },
      calendar::CalendarDate,
 +    reminders::{
 +        ReminderDaemonConfig, ReminderError, SystemNotifier, default_state_file, run_daemon,
 +        run_once, test_notification,
 +    },
 +    services::{
 +        ServiceConfig, ServiceError, SystemCommandRunner, install_service, service_status,
 +        uninstall_service,
 +    },
      tui::{
          AppView, DEFAULT_RENDER_HEIGHT, DEFAULT_RENDER_WIDTH, hit_test_app_date,
          render_app_to_string_with_agenda_source,
      "\n\n",
      "Usage:\n",
      "  rcal [--date YYYY-MM-DD] [--events-file PATH] [--holiday-source off|us-federal|nager] [--holiday-country CC]\n\n",
 +    "  rcal reminders run [--events-file PATH] [--state-file PATH] [--once]\n",
 +    "  rcal reminders install [--events-file PATH]\n",
 +    "  rcal reminders uninstall\n",
 +    "  rcal reminders status\n",
 +    "  rcal reminders test\n\n",
      "Options:\n",
      "  --date YYYY-MM-DD                   Open with the given date selected.\n",
      "  --events-file PATH                  Read and write local user events at PATH.\n",
      "Mouse:\n",
      "  Left click selects a visible date; double-click a visible date to open day view.\n\n",
      "Notes:\n",
 -    "  Real calendar-account integration and reminder notifications are not in this milestone.\n",
 +    "  Reminder services are user-level background jobs. Provider account integration is not in this milestone.\n",
  );
  const VERSION: &str = concat!(env!("CARGO_PKG_NAME"), " ", env!("CARGO_PKG_VERSION"), "\n");
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum CliAction {
      Run(AppConfig),
 +    Reminders(ReminderCliAction),
      Help,
      Version,
+ }
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum ReminderCliAction {
 +    Run(ReminderRunConfig),
 +    Install { events_file: PathBuf },
 +    Uninstall,
 +    Status,
 +    Test,
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ReminderRunConfig {
 +    pub events_file: PathBuf,
 +    pub state_file: PathBuf,
 +    pub once: bool,
 +}
++
  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum CliError {
      DuplicateDate,
      MissingHolidayCountryValue,
      InvalidHolidayCountry(String),
      HolidayCountryRequiresNager,
 +    MissingReminderCommand,
 +    UnknownReminderCommand(String),
 +    DuplicateStateFile,
 +    MissingStateFileValue,
      UnknownArgument(String),
      InvalidDate { input: String, reason: String },
+ }
                      "--holiday-country may only be used with --holiday-source nager"
+                 )
+             }
 +            Self::MissingReminderCommand => write!(
 +                f,
 +                "reminders requires one of: run, install, uninstall, status, test"
 +            ),
 +            Self::UnknownReminderCommand(command) => {
 +                write!(f, "unknown reminders command: {command}")
 +            }
 +            Self::DuplicateStateFile => write!(f, "--state-file may only be provided once"),
 +            Self::MissingStateFileValue => write!(f, "--state-file requires a path"),
              Self::UnknownArgument(arg) => write!(f, "unknown argument: {arg}"),
              Self::InvalidDate { input, reason } => {
                  write!(f, "invalid --date value '{input}': {reason}")
                  Err(err) => io_error_exit(&mut stderr, err),
+             }
+         }
 +        Ok(CliAction::Reminders(action)) => run_reminder_action(action, &mut stdout, &mut stderr),
          Ok(CliAction::Help) => match write!(stdout, "{HELP}") {
              Ok(()) => std::process::ExitCode::SUCCESS,
              Err(err) => io_error_exit(&mut stderr, err),
                  Err(err) => io_error_exit(&mut stderr, err),
+             }
+         }
 +        Ok(CliAction::Reminders(action)) => run_reminder_action(action, &mut stdout, &mut stderr),
          Ok(CliAction::Help) => match write!(stdout, "{HELP}") {
              Ok(()) => std::process::ExitCode::SUCCESS,
              Err(err) => io_error_exit(&mut stderr, err),
+ }
  pub fn parse_args<I>(args: I, today: Date) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let args = args.into_iter().collect::<Vec<_>>();
 +    if let Some(first) = args.first()
 +        && first == "reminders"
 +    {
 +        return parse_reminder_args(args.into_iter().skip(1));
 +    }
++
 +    parse_calendar_args(args, today)
 +}
++
 +fn parse_calendar_args<I>(args: I, today: Date) -> Result<CliAction, CliError>
  where
      I: IntoIterator<Item = OsString>,
+ {
      Ok(CliAction::Run(config))
+ }
 +fn parse_reminder_args<I>(args: I) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut args = args.into_iter();
 +    let command = args.next().ok_or(CliError::MissingReminderCommand)?;
 +    let Some(command) = command.to_str() else {
 +        return Err(CliError::UnknownReminderCommand(display_arg(&command)));
 +    };
++
 +    match command {
 +        "run" => parse_reminder_run_args(args),
 +        "install" => parse_reminder_install_args(args),
 +        "uninstall" => no_extra_reminder_args(args, ReminderCliAction::Uninstall),
 +        "status" => no_extra_reminder_args(args, ReminderCliAction::Status),
 +        "test" => no_extra_reminder_args(args, ReminderCliAction::Test),
 +        "--help" | "-h" => Ok(CliAction::Help),
 +        _ => Err(CliError::UnknownReminderCommand(command.to_string())),
 +    }
 +}
++
 +fn parse_reminder_run_args<I>(args: I) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut events_file = None;
 +    let mut state_file = None;
 +    let mut once = false;
 +    let mut args = args.into_iter();
++
 +    while let Some(arg) = args.next() {
 +        if arg == "--events-file" {
 +            if events_file.is_some() {
 +                return Err(CliError::DuplicateEventsFile);
 +            }
 +            events_file = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingEventsFileValue)?,
 +            ));
 +            continue;
 +        }
 +        if let Some(value) = arg
 +            .to_str()
 +            .and_then(|value| value.strip_prefix("--events-file="))
 +        {
 +            if events_file.is_some() {
 +                return Err(CliError::DuplicateEventsFile);
 +            }
 +            events_file = Some(PathBuf::from(value));
 +            continue;
 +        }
 +        if arg == "--state-file" {
 +            if state_file.is_some() {
 +                return Err(CliError::DuplicateStateFile);
 +            }
 +            state_file = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingStateFileValue)?,
 +            ));
 +            continue;
 +        }
 +        if let Some(value) = arg
 +            .to_str()
 +            .and_then(|value| value.strip_prefix("--state-file="))
 +        {
 +            if state_file.is_some() {
 +                return Err(CliError::DuplicateStateFile);
 +            }
 +            state_file = Some(PathBuf::from(value));
 +            continue;
 +        }
 +        if arg == "--once" {
 +            once = true;
 +            continue;
 +        }
++
 +        return Err(CliError::UnknownArgument(display_arg(&arg)));
 +    }
++
 +    Ok(CliAction::Reminders(ReminderCliAction::Run(
 +        ReminderRunConfig {
 +            events_file: events_file.unwrap_or_else(default_events_file),
 +            state_file: state_file.unwrap_or_else(default_state_file),
 +            once,
 +        },
 +    )))
 +}
++
 +fn parse_reminder_install_args<I>(args: I) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut events_file = None;
 +    let mut args = args.into_iter();
++
 +    while let Some(arg) = args.next() {
 +        if arg == "--events-file" {
 +            if events_file.is_some() {
 +                return Err(CliError::DuplicateEventsFile);
 +            }
 +            events_file = Some(PathBuf::from(
 +                args.next().ok_or(CliError::MissingEventsFileValue)?,
 +            ));
 +            continue;
 +        }
 +        if let Some(value) = arg
 +            .to_str()
 +            .and_then(|value| value.strip_prefix("--events-file="))
 +        {
 +            if events_file.is_some() {
 +                return Err(CliError::DuplicateEventsFile);
 +            }
 +            events_file = Some(PathBuf::from(value));
 +            continue;
 +        }
++
 +        return Err(CliError::UnknownArgument(display_arg(&arg)));
 +    }
++
 +    Ok(CliAction::Reminders(ReminderCliAction::Install {
 +        events_file: events_file.unwrap_or_else(default_events_file),
 +    }))
 +}
++
 +fn no_extra_reminder_args<I>(args: I, action: ReminderCliAction) -> Result<CliAction, CliError>
 +where
 +    I: IntoIterator<Item = OsString>,
 +{
 +    let mut args = args.into_iter();
 +    if let Some(arg) = args.next() {
 +        return Err(CliError::UnknownArgument(display_arg(&arg)));
 +    }
++
 +    Ok(CliAction::Reminders(action))
 +}
++
  fn default_start_date() -> Date {
      OffsetDateTime::now_local()
          .unwrap_or_else(|_| OffsetDateTime::now_utc())
      ConfiguredAgendaSource::from_events_file(config.events_file.clone(), holidays)
+ }
 +fn run_reminder_action(
 +    action: ReminderCliAction,
 +    stdout: &mut impl Write,
 +    stderr: &mut impl Write,
 +) -> std::process::ExitCode {
 +    match action {
 +        ReminderCliAction::Run(config) => {
 +            let daemon_config = ReminderDaemonConfig::new(config.events_file, config.state_file);
 +            let mut notifier = SystemNotifier;
 +            if config.once {
 +                match run_once(
 +                    &daemon_config,
 +                    crate::reminders::current_local_datetime(),
 +                    &mut notifier,
 +                ) {
 +                    Ok(summary) => {
 +                        let _ = writeln!(
 +                            stdout,
 +                            "delivered={} skipped={} failed={}",
 +                            summary.delivered, summary.skipped, summary.failed
 +                        );
 +                        std::process::ExitCode::SUCCESS
 +                    }
 +                    Err(err) => reminder_error_exit(stderr, err),
 +                }
 +            } else {
 +                match run_daemon(daemon_config, &mut notifier) {
 +                    Ok(()) => std::process::ExitCode::SUCCESS,
 +                    Err(err) => reminder_error_exit(stderr, err),
 +                }
 +            }
 +        }
 +        ReminderCliAction::Install { events_file } => {
 +            let config = match ServiceConfig::new(events_file) {
 +                Ok(config) => config,
 +                Err(err) => return service_error_exit(stderr, err),
 +            };
 +            let mut runner = SystemCommandRunner;
 +            match install_service(&config, &mut runner) {
 +                Ok(()) => {
 +                    let _ = writeln!(stdout, "installed reminder service");
 +                    std::process::ExitCode::SUCCESS
 +                }
 +                Err(err) => service_error_exit(stderr, err),
 +            }
 +        }
 +        ReminderCliAction::Uninstall => {
 +            let mut runner = SystemCommandRunner;
 +            match uninstall_service(&mut runner) {
 +                Ok(()) => {
 +                    let _ = writeln!(stdout, "uninstalled reminder service");
 +                    std::process::ExitCode::SUCCESS
 +                }
 +                Err(err) => service_error_exit(stderr, err),
 +            }
 +        }
 +        ReminderCliAction::Status => {
 +            let mut runner = SystemCommandRunner;
 +            match service_status(&mut runner) {
 +                Ok(status) => {
 +                    let _ = writeln!(stdout, "{status}");
 +                    std::process::ExitCode::SUCCESS
 +                }
 +                Err(err) => service_error_exit(stderr, err),
 +            }
 +        }
 +        ReminderCliAction::Test => {
 +            let mut notifier = SystemNotifier;
 +            match test_notification(&mut notifier) {
 +                Ok(()) => {
 +                    let _ = writeln!(stdout, "sent test reminder notification");
 +                    std::process::ExitCode::SUCCESS
 +                }
 +                Err(err) => reminder_error_exit(stderr, err),
 +            }
 +        }
 +    }
 +}
++
  fn run_interactive_terminal<W>(
      stdout: W,
      app: AppState,
      std::process::ExitCode::from(2)
+ }
 +fn reminder_error_exit(stderr: &mut impl Write, err: ReminderError) -> std::process::ExitCode {
 +    let _ = writeln!(stderr, "error: {err}");
 +    std::process::ExitCode::FAILURE
 +}
++
 +fn service_error_exit(stderr: &mut impl Write, err: ServiceError) -> std::process::ExitCode {
 +    let _ = writeln!(stderr, "error: {err}");
 +    std::process::ExitCode::FAILURE
 +}
++
  #[cfg(test)]
  mod tests {
      use super::*;
          );
+     }
 +    #[test]
 +    fn reminder_run_args_set_events_and_state_paths() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_args(
 +            [
 +                arg("reminders"),
 +                arg("run"),
 +                arg("--events-file"),
 +                arg("/tmp/events.json"),
 +                arg("--state-file=/tmp/state.json"),
 +                arg("--once"),
 +            ],
 +            today.into(),
 +        )
 +        .expect("parse succeeds");
++
 +        assert_eq!(
 +            action,
 +            CliAction::Reminders(ReminderCliAction::Run(ReminderRunConfig {
 +                events_file: PathBuf::from("/tmp/events.json"),
 +                state_file: PathBuf::from("/tmp/state.json"),
 +                once: true,
 +            }))
 +        );
 +    }
++
 +    #[test]
 +    fn reminder_install_args_set_events_path() {
 +        let today = date(2026, Month::April, 23);
++
 +        let action = parse_args(
 +            [
 +                arg("reminders"),
 +                arg("install"),
 +                arg("--events-file=/tmp/events.json"),
 +            ],
 +            today.into(),
 +        )
 +        .expect("parse succeeds");
++
 +        assert_eq!(
 +            action,
 +            CliAction::Reminders(ReminderCliAction::Install {
 +                events_file: PathBuf::from("/tmp/events.json"),
 +            })
 +        );
 +    }
++
 +    #[test]
 +    fn reminder_args_are_rejected_when_invalid() {
 +        let today = date(2026, Month::April, 23);
++
 +        assert_eq!(
 +            parse_args([arg("reminders")], today.into()).expect_err("missing command fails"),
 +            CliError::MissingReminderCommand
 +        );
 +        assert_eq!(
 +            parse_args([arg("reminders"), arg("bogus")], today.into())
 +                .expect_err("unknown command fails"),
 +            CliError::UnknownReminderCommand("bogus".to_string())
 +        );
 +        assert_eq!(
 +            parse_args(
 +                [
 +                    arg("reminders"),
 +                    arg("run"),
 +                    arg("--state-file"),
 +                    arg("/tmp/one.json"),
 +                    arg("--state-file=/tmp/two.json"),
 +                ],
 +                today.into(),
 +            )
 +            .expect_err("duplicate state path fails"),
 +            CliError::DuplicateStateFile
 +        );
 +    }
++
      #[test]
      fn invalid_holiday_options_are_rejected() {
          let today = date(2026, Month::April, 23);

src/lib.rsmodified

  pub mod calendar;
  pub mod cli;
  pub mod layout;
 +pub mod reminders;
 +pub mod services;
  pub mod tui;

src/reminders.rsadded

 +use std::{
 +    collections::HashMap,
 +    error::Error,
 +    fmt, fs, io,
 +    path::{Path, PathBuf},
 +    thread,
 +    time::Duration as StdDuration,
 +};
++
 +use directories::ProjectDirs;
 +use fs2::FileExt;
 +use notify_rust::Notification;
 +use serde::{Deserialize, Serialize};
 +use time::{Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time};
++
 +use crate::{
 +    agenda::{
 +        AgendaSource, ConfiguredAgendaSource, DateRange, Event, EventDateTime, EventTiming,
 +        HolidayProvider,
 +    },
 +    calendar::CalendarDate,
 +};
++
 +const STATE_VERSION: u8 = 1;
 +const GRACE_MINUTES: i64 = 10;
 +const PRUNE_AFTER_DAYS: i32 = 30;
 +const LOOKAHEAD_DAYS: i32 = 47;
 +const POLL_INTERVAL: StdDuration = StdDuration::from_secs(30);
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ReminderDaemonConfig {
 +    pub events_file: PathBuf,
 +    pub state_file: PathBuf,
 +    pub poll_interval: StdDuration,
 +    pub grace: Duration,
 +}
++
 +impl ReminderDaemonConfig {
 +    pub fn new(events_file: PathBuf, state_file: PathBuf) -> Self {
 +        Self {
 +            events_file,
 +            state_file,
 +            poll_interval: POLL_INTERVAL,
 +            grace: Duration::minutes(GRACE_MINUTES),
 +        }
 +    }
++
 +    pub fn lock_file(&self) -> PathBuf {
 +        self.state_file.with_extension("lock")
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ReminderInstance {
 +    pub key: String,
 +    pub event_id: String,
 +    pub title: String,
 +    pub location: Option<String>,
 +    pub event_start: EventDateTime,
 +    pub fire_at: PrimitiveDateTime,
 +    pub minutes_before: u16,
 +    pub all_day: bool,
 +}
++
 +impl ReminderInstance {
 +    pub fn notification_title(&self) -> String {
 +        format!("Reminder: {}", self.title)
 +    }
++
 +    pub fn notification_body(&self) -> String {
 +        let when = if self.all_day {
 +            format!("All day on {}", self.event_start.date)
 +        } else {
 +            format!(
 +                "Starts at {:02}:{:02} on {}",
 +                self.event_start.time.hour(),
 +                self.event_start.time.minute(),
 +                self.event_start.date
 +            )
 +        };
++
 +        if let Some(location) = &self.location {
 +            format!("{when}\nLocation: {location}")
 +        } else {
 +            when
 +        }
 +    }
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ReminderRunSummary {
 +    pub delivered: usize,
 +    pub skipped: usize,
 +    pub failed: usize,
 +}
++
 +pub trait Notifier {
 +    fn notify(&mut self, reminder: &ReminderInstance) -> Result<(), ReminderError>;
 +}
++
 +#[derive(Debug, Default)]
 +pub struct SystemNotifier;
++
 +impl Notifier for SystemNotifier {
 +    fn notify(&mut self, reminder: &ReminderInstance) -> Result<(), ReminderError> {
 +        Notification::new()
 +            .summary(&reminder.notification_title())
 +            .body(&reminder.notification_body())
 +            .show()
 +            .map(|_| ())
 +            .map_err(|err| ReminderError::Notification(err.to_string()))
 +    }
 +}
++
 +pub fn default_state_file() -> PathBuf {
 +    if let Some(project_dirs) = ProjectDirs::from("com", "tenseleyFlow", "rcal") {
 +        if let Some(state_dir) = project_dirs.state_dir() {
 +            return state_dir.join("reminders-state.json");
 +        }
++
 +        return project_dirs.data_local_dir().join("reminders-state.json");
 +    }
++
 +    std::env::temp_dir()
 +        .join("rcal")
 +        .join("reminders-state.json")
 +}
++
 +pub fn default_log_file() -> PathBuf {
 +    if let Some(project_dirs) = ProjectDirs::from("com", "tenseleyFlow", "rcal") {
 +        return project_dirs.cache_dir().join("reminders.log");
 +    }
++
 +    std::env::temp_dir().join("rcal").join("reminders.log")
 +}
++
 +pub fn current_local_datetime() -> PrimitiveDateTime {
 +    let now = OffsetDateTime::now_local().unwrap_or_else(|_| OffsetDateTime::now_utc());
 +    PrimitiveDateTime::new(now.date(), now.time())
 +}
++
 +pub fn run_daemon(
 +    config: ReminderDaemonConfig,
 +    notifier: &mut dyn Notifier,
 +) -> Result<(), ReminderError> {
 +    let _lock = DaemonLock::acquire(&config.lock_file())?;
 +    loop {
 +        let now = current_local_datetime();
 +        let _ = run_once(&config, now, notifier)?;
 +        thread::sleep(config.poll_interval);
 +    }
 +}
++
 +pub fn run_once(
 +    config: &ReminderDaemonConfig,
 +    now: PrimitiveDateTime,
 +    notifier: &mut dyn Notifier,
 +) -> Result<ReminderRunSummary, ReminderError> {
 +    let source =
 +        ConfiguredAgendaSource::from_events_file(&config.events_file, HolidayProvider::off())
 +            .map_err(|err| ReminderError::Events(err.to_string()))?;
 +    let mut state = ReminderState::load(&config.state_file)?;
 +    let instances = reminder_instances(&source, now);
 +    let mut delivered = 0;
 +    let mut skipped = 0;
 +    let mut failed = 0;
 +    let expires_before = now - config.grace;
++
 +    for instance in instances {
 +        if state.contains(&instance.key) {
 +            continue;
 +        }
++
 +        if instance.fire_at > now {
 +            continue;
 +        }
++
 +        if instance.fire_at < expires_before {
 +            state.record(instance, ReminderStatus::Skipped);
 +            skipped += 1;
 +            continue;
 +        }
++
 +        match notifier.notify(&instance) {
 +            Ok(()) => {
 +                state.record(instance, ReminderStatus::Delivered);
 +                delivered += 1;
 +            }
 +            Err(_) => {
 +                failed += 1;
 +            }
 +        }
 +    }
++
 +    state.prune(now.date());
 +    state.save(&config.state_file)?;
 +    Ok(ReminderRunSummary {
 +        delivered,
 +        skipped,
 +        failed,
 +    })
 +}
++
 +pub fn test_notification(notifier: &mut dyn Notifier) -> Result<(), ReminderError> {
 +    let date = CalendarDate::from(current_local_datetime().date());
 +    let reminder = ReminderInstance {
 +        key: "test".to_string(),
 +        event_id: "test".to_string(),
 +        title: "rcal reminder test".to_string(),
 +        location: None,
 +        event_start: EventDateTime::new(date, current_local_datetime().time()),
 +        fire_at: current_local_datetime(),
 +        minutes_before: 0,
 +        all_day: false,
 +    };
 +    notifier.notify(&reminder)
 +}
++
 +pub fn reminder_instances(
 +    source: &dyn AgendaSource,
 +    now: PrimitiveDateTime,
 +) -> Vec<ReminderInstance> {
 +    let range = DateRange::new(
 +        CalendarDate::from(now.date()).add_days(-PRUNE_AFTER_DAYS),
 +        CalendarDate::from(now.date()).add_days(LOOKAHEAD_DAYS),
 +    )
 +    .expect("reminder scan range is valid");
 +    let mut instances = source
 +        .events_intersecting(range)
 +        .into_iter()
 +        .filter(Event::is_local)
 +        .flat_map(reminders_for_event)
 +        .collect::<Vec<_>>();
 +    instances.sort_by(|left, right| {
 +        left.fire_at
 +            .cmp(&right.fire_at)
 +            .then(left.title.cmp(&right.title))
 +            .then(left.key.cmp(&right.key))
 +    });
 +    instances
 +}
++
 +fn reminders_for_event(event: Event) -> Vec<ReminderInstance> {
 +    let Some(event_start) = reminder_event_start(&event) else {
 +        return Vec::new();
 +    };
 +    let all_day = matches!(event.timing, EventTiming::AllDay { .. });
 +    let start_at = event_datetime_to_primitive(event_start);
++
 +    event
 +        .reminders
 +        .iter()
 +        .map(|reminder| {
 +            let fire_at = start_at - Duration::minutes(i64::from(reminder.minutes_before));
 +            ReminderInstance {
 +                key: reminder_key(&event, event_start, reminder.minutes_before),
 +                event_id: event.id.clone(),
 +                title: event.title.clone(),
 +                location: event.location.clone(),
 +                event_start,
 +                fire_at,
 +                minutes_before: reminder.minutes_before,
 +                all_day,
 +            }
 +        })
 +        .collect()
 +}
++
 +fn reminder_event_start(event: &Event) -> Option<EventDateTime> {
 +    match event.timing {
 +        EventTiming::AllDay { date } => Some(EventDateTime::new(date, Time::MIDNIGHT)),
 +        EventTiming::Timed { start, .. } => Some(start),
 +    }
 +}
++
 +fn event_datetime_to_primitive(datetime: EventDateTime) -> PrimitiveDateTime {
 +    PrimitiveDateTime::new(datetime.date.into(), datetime.time)
 +}
++
 +fn reminder_key(event: &Event, event_start: EventDateTime, minutes_before: u16) -> String {
 +    format!(
 +        "{}|{}T{:02}:{:02}|{}m",
 +        event.id,
 +        event_start.date,
 +        event_start.time.hour(),
 +        event_start.time.minute(),
 +        minutes_before
 +    )
 +}
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +struct ReminderState {
 +    records: HashMap<String, ReminderStateRecord>,
 +}
++
 +impl ReminderState {
 +    fn empty() -> Self {
 +        Self {
 +            records: HashMap::new(),
 +        }
 +    }
++
 +    fn load(path: &Path) -> Result<Self, ReminderError> {
 +        let body = match fs::read_to_string(path) {
 +            Ok(body) => body,
 +            Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(Self::empty()),
 +            Err(err) => {
 +                return Err(ReminderError::StateRead {
 +                    path: path.to_path_buf(),
 +                    reason: err.to_string(),
 +                });
 +            }
 +        };
 +        let file = serde_json::from_str::<ReminderStateFile>(&body).map_err(|err| {
 +            ReminderError::StateParse {
 +                path: path.to_path_buf(),
 +                reason: err.to_string(),
 +            }
 +        })?;
 +        if file.version != STATE_VERSION {
 +            return Err(ReminderError::StateParse {
 +                path: path.to_path_buf(),
 +                reason: format!("unsupported reminder state version {}", file.version),
 +            });
 +        }
 +        for record in &file.reminders {
 +            if parse_date(&record.fire_date).is_none() || parse_time(&record.fire_time).is_none() {
 +                return Err(ReminderError::StateParse {
 +                    path: path.to_path_buf(),
 +                    reason: format!("invalid reminder fire time for key '{}'", record.key),
 +                });
 +            }
 +        }
++
 +        Ok(Self {
 +            records: file
 +                .reminders
 +                .into_iter()
 +                .map(|record| (record.key.clone(), record))
 +                .collect(),
 +        })
 +    }
++
 +    fn save(&self, path: &Path) -> Result<(), ReminderError> {
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent).map_err(|err| ReminderError::StateWrite {
 +                path: parent.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
 +        }
++
 +        let mut reminders = self.records.values().cloned().collect::<Vec<_>>();
 +        reminders.sort_by(|left, right| left.key.cmp(&right.key));
 +        let file = ReminderStateFile {
 +            version: STATE_VERSION,
 +            reminders,
 +        };
 +        let body =
 +            serde_json::to_string_pretty(&file).map_err(|err| ReminderError::StateWrite {
 +                path: path.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
 +        let temp_path = path.with_extension(format!(
 +            "{}.tmp",
 +            path.extension()
 +                .and_then(|extension| extension.to_str())
 +                .unwrap_or("json")
 +        ));
 +        fs::write(&temp_path, body).map_err(|err| ReminderError::StateWrite {
 +            path: temp_path.clone(),
 +            reason: err.to_string(),
 +        })?;
 +        fs::rename(&temp_path, path).map_err(|err| ReminderError::StateWrite {
 +            path: path.to_path_buf(),
 +            reason: err.to_string(),
 +        })
 +    }
++
 +    fn contains(&self, key: &str) -> bool {
 +        self.records.contains_key(key)
 +    }
++
 +    fn record(&mut self, instance: ReminderInstance, status: ReminderStatus) {
 +        self.records.insert(
 +            instance.key.clone(),
 +            ReminderStateRecord {
 +                key: instance.key,
 +                status,
 +                fire_date: instance.fire_at.date().to_string(),
 +                fire_time: format_time(instance.fire_at.time()),
 +            },
 +        );
 +    }
++
 +    fn prune(&mut self, today: Date) {
 +        let cutoff = CalendarDate::from(today).add_days(-PRUNE_AFTER_DAYS);
 +        self.records.retain(|_, record| {
 +            record
 +                .fire_date_value()
 +                .map(|date| date >= cutoff)
 +                .unwrap_or(true)
 +        });
 +    }
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 +struct ReminderStateFile {
 +    version: u8,
 +    #[serde(default)]
 +    reminders: Vec<ReminderStateRecord>,
 +}
++
 +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 +struct ReminderStateRecord {
 +    key: String,
 +    status: ReminderStatus,
 +    fire_date: String,
 +    fire_time: String,
 +}
++
 +impl ReminderStateRecord {
 +    fn fire_date_value(&self) -> Option<CalendarDate> {
 +        parse_date(&self.fire_date)
 +    }
 +}
++
 +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 +#[serde(rename_all = "snake_case")]
 +enum ReminderStatus {
 +    Delivered,
 +    Skipped,
 +}
++
 +struct DaemonLock {
 +    _file: fs::File,
 +}
++
 +impl DaemonLock {
 +    fn acquire(path: &Path) -> Result<Self, ReminderError> {
 +        if let Some(parent) = path.parent() {
 +            fs::create_dir_all(parent).map_err(|err| ReminderError::Lock {
 +                path: parent.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
 +        }
 +        let file = fs::OpenOptions::new()
 +            .read(true)
 +            .write(true)
 +            .create(true)
 +            .truncate(false)
 +            .open(path)
 +            .map_err(|err| ReminderError::Lock {
 +                path: path.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
 +        file.try_lock_exclusive()
 +            .map_err(|err| ReminderError::Lock {
 +                path: path.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
++
 +        Ok(Self { _file: file })
 +    }
 +}
++
 +#[derive(Debug)]
 +pub enum ReminderError {
 +    Events(String),
 +    Notification(String),
 +    StateRead { path: PathBuf, reason: String },
 +    StateParse { path: PathBuf, reason: String },
 +    StateWrite { path: PathBuf, reason: String },
 +    Lock { path: PathBuf, reason: String },
 +}
++
 +impl fmt::Display for ReminderError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        match self {
 +            Self::Events(reason) => write!(f, "failed to load reminder events: {reason}"),
 +            Self::Notification(reason) => write!(f, "failed to send notification: {reason}"),
 +            Self::StateRead { path, reason } => {
 +                write!(
 +                    f,
 +                    "failed to read reminder state {}: {reason}",
 +                    path.display()
 +                )
 +            }
 +            Self::StateParse { path, reason } => {
 +                write!(
 +                    f,
 +                    "failed to parse reminder state {}: {reason}",
 +                    path.display()
 +                )
 +            }
 +            Self::StateWrite { path, reason } => {
 +                write!(
 +                    f,
 +                    "failed to write reminder state {}: {reason}",
 +                    path.display()
 +                )
 +            }
 +            Self::Lock { path, reason } => {
 +                write!(
 +                    f,
 +                    "failed to lock reminder daemon {}: {reason}",
 +                    path.display()
 +                )
 +            }
 +        }
 +    }
 +}
++
 +impl Error for ReminderError {}
++
 +fn format_time(time: Time) -> String {
 +    format!("{:02}:{:02}", time.hour(), time.minute())
 +}
++
 +fn parse_date(value: &str) -> Option<CalendarDate> {
 +    let mut parts = value.split('-');
 +    let year = parts.next()?.parse::<i32>().ok()?;
 +    let month = parts.next()?.parse::<u8>().ok()?;
 +    let day = parts.next()?.parse::<u8>().ok()?;
 +    if parts.next().is_some() {
 +        return None;
 +    }
 +    CalendarDate::from_ymd(year, Month::try_from(month).ok()?, day).ok()
 +}
++
 +fn parse_time(value: &str) -> Option<Time> {
 +    let mut parts = value.split(':');
 +    let hour = parts.next()?.parse::<u8>().ok()?;
 +    let minute = parts.next()?.parse::<u8>().ok()?;
 +    if parts.next().is_some() {
 +        return None;
 +    }
 +    Time::from_hms(hour, minute, 0).ok()
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
 +    use time::Month;
++
 +    use crate::agenda::{
 +        CreateEventDraft, CreateEventTiming, Event, InMemoryAgendaSource, RecurrenceEnd,
 +        RecurrenceFrequency, RecurrenceRule, Reminder, SourceMetadata,
 +    };
++
 +    #[derive(Default)]
 +    struct FakeNotifier {
 +        sent: Vec<String>,
 +        fail: bool,
 +    }
++
 +    impl Notifier for FakeNotifier {
 +        fn notify(&mut self, reminder: &ReminderInstance) -> Result<(), ReminderError> {
 +            if self.fail {
 +                Err(ReminderError::Notification("boom".to_string()))
 +            } else {
 +                self.sent.push(reminder.key.clone());
 +                Ok(())
 +            }
 +        }
 +    }
++
 +    fn date(day: u8) -> CalendarDate {
 +        CalendarDate::from_ymd(2026, Month::April, day).expect("valid test date")
 +    }
++
 +    fn at(date: CalendarDate, hour: u8, minute: u8) -> EventDateTime {
 +        EventDateTime::new(date, Time::from_hms(hour, minute, 0).expect("valid time"))
 +    }
++
 +    fn now(day: u8, hour: u8, minute: u8) -> PrimitiveDateTime {
 +        PrimitiveDateTime::new(
 +            date(day).into(),
 +            Time::from_hms(hour, minute, 0).expect("valid time"),
 +        )
 +    }
++
 +    fn timed_event(id: &str, title: &str, start: EventDateTime, end: EventDateTime) -> Event {
 +        Event::timed(id, title, start, end, SourceMetadata::local()).expect("valid timed event")
 +    }
++
 +    fn temp_path(name: &str, file: &str) -> PathBuf {
 +        std::env::temp_dir()
 +            .join(format!("rcal-reminders-test-{}", std::process::id()))
 +            .join(name)
 +            .join(file)
 +    }
++
 +    #[test]
 +    fn reminder_fire_times_cover_timed_all_day_cross_midnight_and_recurring_events() {
 +        let day = date(23);
 +        let timed = timed_event("timed", "Timed", at(day, 9, 0), at(day, 10, 0))
 +            .with_reminders(vec![Reminder::minutes_before(15)]);
 +        let all_day = Event::all_day("all-day", "All day", day, SourceMetadata::local())
 +            .with_reminders(vec![Reminder::minutes_before(60)]);
 +        let cross_midnight =
 +            timed_event("late", "Late", at(day, 23, 30), at(day.add_days(1), 1, 0))
 +                .with_reminders(vec![Reminder::minutes_before(30)]);
 +        let recurring = timed_event("daily", "Daily", at(day, 8, 0), at(day, 8, 30))
 +            .with_reminders(vec![Reminder::minutes_before(10)])
 +            .with_recurrence(RecurrenceRule {
 +                frequency: RecurrenceFrequency::Daily,
 +                interval: 1,
 +                end: RecurrenceEnd::Count(2),
 +                weekdays: Vec::new(),
 +                monthly: None,
 +                yearly: None,
 +            });
 +        let source = InMemoryAgendaSource::with_events_and_holidays(
 +            vec![timed, all_day, cross_midnight, recurring],
 +            Vec::new(),
 +        );
++
 +        let instances = reminder_instances(&source, now(23, 9, 0));
 +        let keys = instances
 +            .iter()
 +            .map(|instance| (instance.event_id.as_str(), instance.fire_at))
 +            .collect::<Vec<_>>();
++
 +        assert!(keys.contains(&("timed", now(23, 8, 45))));
 +        assert!(keys.contains(&("all-day", now(22, 23, 0))));
 +        assert!(keys.contains(&("late", now(23, 23, 0))));
 +        assert!(
 +            keys.iter()
 +                .any(|(id, fire_at)| id.starts_with("daily#") && *fire_at == now(24, 7, 50))
 +        );
 +    }
++
 +    #[test]
 +    fn run_once_delivers_within_grace_and_skips_older_reminders() {
 +        let dir = temp_path("grace", "events.json");
 +        let _ = std::fs::remove_dir_all(dir.parent().expect("path has parent"));
 +        let state_file = temp_path("grace", "state.json");
 +        let mut source = ConfiguredAgendaSource::from_events_file(&dir, HolidayProvider::off())
 +            .expect("events load");
 +        source
 +            .create_event(CreateEventDraft {
 +                title: "Recent".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(date(23), 9, 5),
 +                    end: at(date(23), 10, 0),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: vec![Reminder::minutes_before(10)],
 +                recurrence: None,
 +            })
 +            .expect("event saves");
 +        source
 +            .create_event(CreateEventDraft {
 +                title: "Old".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(date(23), 8, 30),
 +                    end: at(date(23), 9, 0),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: vec![Reminder::minutes_before(30)],
 +                recurrence: None,
 +            })
 +            .expect("event saves");
 +        let config = ReminderDaemonConfig::new(dir.clone(), state_file);
 +        let mut notifier = FakeNotifier::default();
++
 +        let summary = run_once(&config, now(23, 9, 0), &mut notifier).expect("run succeeds");
++
 +        let _ = std::fs::remove_dir_all(dir.parent().expect("test dir exists"));
 +        assert_eq!(summary.delivered, 1);
 +        assert_eq!(summary.skipped, 1);
 +        assert_eq!(notifier.sent.len(), 1);
 +    }
++
 +    #[test]
 +    fn delivered_state_dedupes_across_runs() {
 +        let events_file = temp_path("dedupe", "events.json");
 +        let _ = std::fs::remove_dir_all(events_file.parent().expect("path has parent"));
 +        let state_file = temp_path("dedupe", "state.json");
 +        let mut source =
 +            ConfiguredAgendaSource::from_events_file(&events_file, HolidayProvider::off())
 +                .expect("events load");
 +        source
 +            .create_event(CreateEventDraft {
 +                title: "Planning".to_string(),
 +                timing: CreateEventTiming::Timed {
 +                    start: at(date(23), 9, 5),
 +                    end: at(date(23), 10, 0),
 +                },
 +                location: None,
 +                notes: None,
 +                reminders: vec![Reminder::minutes_before(10)],
 +                recurrence: None,
 +            })
 +            .expect("event saves");
 +        let config = ReminderDaemonConfig::new(events_file.clone(), state_file);
 +        let mut notifier = FakeNotifier::default();
 +        let first = run_once(&config, now(23, 9, 0), &mut notifier).expect("first run");
 +        let second = run_once(&config, now(23, 9, 1), &mut notifier).expect("second run");
++
 +        let _ = std::fs::remove_dir_all(events_file.parent().expect("test dir exists"));
 +        assert_eq!(first.delivered, 1);
 +        assert_eq!(second.delivered, 0);
 +        assert_eq!(notifier.sent.len(), 1);
 +    }
++
 +    #[test]
 +    fn malformed_state_is_a_clear_error_and_prune_drops_old_records() {
 +        let state_file = temp_path("state", "state.json");
 +        let _ = std::fs::remove_dir_all(state_file.parent().expect("path has parent"));
 +        std::fs::create_dir_all(state_file.parent().expect("path has parent"))
 +            .expect("dir creates");
 +        std::fs::write(&state_file, "not-json").expect("state writes");
 +        let err = ReminderState::load(&state_file).expect_err("malformed state fails");
 +        assert!(err.to_string().contains("failed to parse reminder state"));
++
 +        let mut state = ReminderState::empty();
 +        state.records.insert(
 +            "old".to_string(),
 +            ReminderStateRecord {
 +                key: "old".to_string(),
 +                status: ReminderStatus::Delivered,
 +                fire_date: "2026-03-01".to_string(),
 +                fire_time: "09:00".to_string(),
 +            },
 +        );
 +        state.records.insert(
 +            "new".to_string(),
 +            ReminderStateRecord {
 +                key: "new".to_string(),
 +                status: ReminderStatus::Delivered,
 +                fire_date: "2026-04-20".to_string(),
 +                fire_time: "09:00".to_string(),
 +            },
 +        );
 +        state.prune(date(23).into());
++
 +        let _ = std::fs::remove_dir_all(state_file.parent().expect("test dir exists"));
 +        assert!(!state.records.contains_key("old"));
 +        assert!(state.records.contains_key("new"));
 +    }
++
 +    #[test]
 +    fn notification_body_includes_time_and_location() {
 +        let reminder = ReminderInstance {
 +            key: "key".to_string(),
 +            event_id: "event".to_string(),
 +            title: "Planning".to_string(),
 +            location: Some("Room 1".to_string()),
 +            event_start: at(date(23), 9, 0),
 +            fire_at: now(23, 8, 50),
 +            minutes_before: 10,
 +            all_day: false,
 +        };
++
 +        assert_eq!(reminder.notification_title(), "Reminder: Planning");
 +        assert!(reminder.notification_body().contains("Starts at 09:00"));
 +        assert!(reminder.notification_body().contains("Location: Room 1"));
 +    }
 +}

src/services.rsadded

 +use std::{
 +    error::Error,
 +    fmt, fs,
 +    path::{Path, PathBuf},
 +    process::Command,
 +};
++
 +use directories::BaseDirs;
++
 +use crate::{
 +    agenda::default_events_file,
 +    reminders::{default_log_file, default_state_file},
 +};
++
 +const SERVICE_LABEL: &str = "com.tenseleyflow.rcal.reminders";
 +#[cfg(target_os = "linux")]
 +const SYSTEMD_SERVICE_NAME: &str = "rcal-reminders.service";
 +const WINDOWS_TASK_NAME: &str = "rcal-reminders";
++
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub struct ServiceConfig {
 +    pub executable: PathBuf,
 +    pub events_file: PathBuf,
 +    pub state_file: PathBuf,
 +    pub log_file: PathBuf,
 +}
++
 +impl ServiceConfig {
 +    pub fn new(events_file: PathBuf) -> Result<Self, ServiceError> {
 +        let executable = std::env::current_exe().map_err(|err| ServiceError::CurrentExe {
 +            reason: err.to_string(),
 +        })?;
 +        Ok(Self {
 +            executable,
 +            events_file,
 +            state_file: default_state_file(),
 +            log_file: default_log_file(),
 +        })
 +    }
 +}
++
 +impl Default for ServiceConfig {
 +    fn default() -> Self {
 +        Self {
 +            executable: PathBuf::from("rcal"),
 +            events_file: default_events_file(),
 +            state_file: default_state_file(),
 +            log_file: default_log_file(),
 +        }
 +    }
 +}
++
 +pub trait CommandRunner {
 +    fn run(&mut self, program: &str, args: &[String]) -> Result<(), ServiceError>;
 +    fn status(&mut self, program: &str, args: &[String]) -> Result<bool, ServiceError>;
 +}
++
 +#[derive(Debug, Default)]
 +pub struct SystemCommandRunner;
++
 +impl CommandRunner for SystemCommandRunner {
 +    fn run(&mut self, program: &str, args: &[String]) -> Result<(), ServiceError> {
 +        let status =
 +            Command::new(program)
 +                .args(args)
 +                .status()
 +                .map_err(|err| ServiceError::Command {
 +                    program: program.to_string(),
 +                    reason: err.to_string(),
 +                })?;
 +        if status.success() {
 +            Ok(())
 +        } else {
 +            Err(ServiceError::Command {
 +                program: program.to_string(),
 +                reason: format!("exited with status {status}"),
 +            })
 +        }
 +    }
++
 +    fn status(&mut self, program: &str, args: &[String]) -> Result<bool, ServiceError> {
 +        let status =
 +            Command::new(program)
 +                .args(args)
 +                .status()
 +                .map_err(|err| ServiceError::Command {
 +                    program: program.to_string(),
 +                    reason: err.to_string(),
 +                })?;
 +        Ok(status.success())
 +    }
 +}
++
 +pub fn install_service(
 +    config: &ServiceConfig,
 +    runner: &mut dyn CommandRunner,
 +) -> Result<(), ServiceError> {
 +    platform_installer().install(config, runner)
 +}
++
 +pub fn uninstall_service(runner: &mut dyn CommandRunner) -> Result<(), ServiceError> {
 +    platform_installer().uninstall(runner)
 +}
++
 +pub fn service_status(runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError> {
 +    platform_installer().status(runner)
 +}
++
 +fn platform_installer() -> Box<dyn ServiceInstaller> {
 +    #[cfg(target_os = "macos")]
 +    {
 +        Box::new(MacLaunchAgent)
 +    }
 +    #[cfg(target_os = "linux")]
 +    {
 +        Box::new(LinuxSystemdUser)
 +    }
 +    #[cfg(target_os = "windows")]
 +    {
 +        Box::new(WindowsScheduledTask)
 +    }
 +    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 +    {
 +        Box::new(UnsupportedInstaller)
 +    }
 +}
++
 +trait ServiceInstaller {
 +    fn install(
 +        &self,
 +        config: &ServiceConfig,
 +        runner: &mut dyn CommandRunner,
 +    ) -> Result<(), ServiceError>;
 +    fn uninstall(&self, runner: &mut dyn CommandRunner) -> Result<(), ServiceError>;
 +    fn status(&self, runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError>;
 +}
++
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ServiceStatus {
 +    Installed,
 +    NotInstalled,
 +}
++
 +impl fmt::Display for ServiceStatus {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        match self {
 +            Self::Installed => write!(f, "installed"),
 +            Self::NotInstalled => write!(f, "not installed"),
 +        }
 +    }
 +}
++
 +#[derive(Debug)]
 +struct MacLaunchAgent;
++
 +impl MacLaunchAgent {
 +    fn plist_path() -> Result<PathBuf, ServiceError> {
 +        Ok(home_dir()?
 +            .join("Library")
 +            .join("LaunchAgents")
 +            .join(format!("{SERVICE_LABEL}.plist")))
 +    }
 +}
++
 +impl ServiceInstaller for MacLaunchAgent {
 +    fn install(
 +        &self,
 +        config: &ServiceConfig,
 +        runner: &mut dyn CommandRunner,
 +    ) -> Result<(), ServiceError> {
 +        let path = Self::plist_path()?;
 +        if let Some(parent) = config.log_file.parent() {
 +            fs::create_dir_all(parent).map_err(|err| ServiceError::Write {
 +                path: parent.to_path_buf(),
 +                reason: err.to_string(),
 +            })?;
 +        }
 +        write_file(&path, &mac_launch_agent_plist(config))?;
 +        let _ = runner.run("launchctl", &["unload".to_string(), path_string(&path)]);
 +        runner.run(
 +            "launchctl",
 +            &["load".to_string(), "-w".to_string(), path_string(&path)],
 +        )
 +    }
++
 +    fn uninstall(&self, runner: &mut dyn CommandRunner) -> Result<(), ServiceError> {
 +        let path = Self::plist_path()?;
 +        if path.exists() {
 +            let _ = runner.run("launchctl", &["unload".to_string(), path_string(&path)]);
 +            fs::remove_file(&path).map_err(|err| ServiceError::Write {
 +                path: path.clone(),
 +                reason: err.to_string(),
 +            })?;
 +        }
 +        Ok(())
 +    }
++
 +    fn status(&self, runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError> {
 +        let path = Self::plist_path()?;
 +        if !path.exists() {
 +            return Ok(ServiceStatus::NotInstalled);
 +        }
 +        if runner.status(
 +            "launchctl",
 +            &["list".to_string(), SERVICE_LABEL.to_string()],
 +        )? {
 +            Ok(ServiceStatus::Installed)
 +        } else {
 +            Ok(ServiceStatus::NotInstalled)
 +        }
 +    }
 +}
++
 +#[cfg(target_os = "linux")]
 +#[derive(Debug)]
 +struct LinuxSystemdUser;
++
 +#[cfg(target_os = "linux")]
 +impl LinuxSystemdUser {
 +    fn unit_path() -> Result<PathBuf, ServiceError> {
 +        let config_home = if let Some(config_home) = std::env::var_os("XDG_CONFIG_HOME") {
 +            PathBuf::from(config_home)
 +        } else {
 +            home_dir()?.join(".config")
 +        };
 +        Ok(config_home
 +            .join("systemd")
 +            .join("user")
 +            .join(SYSTEMD_SERVICE_NAME))
 +    }
 +}
++
 +#[cfg(target_os = "linux")]
 +impl ServiceInstaller for LinuxSystemdUser {
 +    fn install(
 +        &self,
 +        config: &ServiceConfig,
 +        runner: &mut dyn CommandRunner,
 +    ) -> Result<(), ServiceError> {
 +        let path = Self::unit_path()?;
 +        write_file(&path, &linux_systemd_unit(config))?;
 +        runner.run(
 +            "systemctl",
 +            &["--user".to_string(), "daemon-reload".to_string()],
 +        )?;
 +        runner.run(
 +            "systemctl",
 +            &[
 +                "--user".to_string(),
 +                "enable".to_string(),
 +                "--now".to_string(),
 +                SYSTEMD_SERVICE_NAME.to_string(),
 +            ],
 +        )
 +    }
++
 +    fn uninstall(&self, runner: &mut dyn CommandRunner) -> Result<(), ServiceError> {
 +        let path = Self::unit_path()?;
 +        let _ = runner.run(
 +            "systemctl",
 +            &[
 +                "--user".to_string(),
 +                "disable".to_string(),
 +                "--now".to_string(),
 +                SYSTEMD_SERVICE_NAME.to_string(),
 +            ],
 +        );
 +        if path.exists() {
 +            fs::remove_file(&path).map_err(|err| ServiceError::Write {
 +                path: path.clone(),
 +                reason: err.to_string(),
 +            })?;
 +        }
 +        runner.run(
 +            "systemctl",
 +            &["--user".to_string(), "daemon-reload".to_string()],
 +        )
 +    }
++
 +    fn status(&self, runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError> {
 +        let path = Self::unit_path()?;
 +        if !path.exists() {
 +            return Ok(ServiceStatus::NotInstalled);
 +        }
 +        if runner.status(
 +            "systemctl",
 +            &[
 +                "--user".to_string(),
 +                "is-active".to_string(),
 +                "--quiet".to_string(),
 +                SYSTEMD_SERVICE_NAME.to_string(),
 +            ],
 +        )? {
 +            Ok(ServiceStatus::Installed)
 +        } else {
 +            Ok(ServiceStatus::NotInstalled)
 +        }
 +    }
 +}
++
 +#[cfg(target_os = "windows")]
 +#[derive(Debug)]
 +struct WindowsScheduledTask;
++
 +#[cfg(target_os = "windows")]
 +impl ServiceInstaller for WindowsScheduledTask {
 +    fn install(
 +        &self,
 +        config: &ServiceConfig,
 +        runner: &mut dyn CommandRunner,
 +    ) -> Result<(), ServiceError> {
 +        runner.run("schtasks", &windows_schtasks_create_args(config))?;
 +        runner.run(
 +            "schtasks",
 +            &[
 +                "/Run".to_string(),
 +                "/TN".to_string(),
 +                WINDOWS_TASK_NAME.to_string(),
 +            ],
 +        )
 +    }
++
 +    fn uninstall(&self, runner: &mut dyn CommandRunner) -> Result<(), ServiceError> {
 +        let _ = runner.run(
 +            "schtasks",
 +            &[
 +                "/End".to_string(),
 +                "/TN".to_string(),
 +                WINDOWS_TASK_NAME.to_string(),
 +            ],
 +        );
 +        runner.run(
 +            "schtasks",
 +            &[
 +                "/Delete".to_string(),
 +                "/TN".to_string(),
 +                WINDOWS_TASK_NAME.to_string(),
 +                "/F".to_string(),
 +            ],
 +        )
 +    }
++
 +    fn status(&self, runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError> {
 +        if runner.status(
 +            "schtasks",
 +            &[
 +                "/Query".to_string(),
 +                "/TN".to_string(),
 +                WINDOWS_TASK_NAME.to_string(),
 +            ],
 +        )? {
 +            Ok(ServiceStatus::Installed)
 +        } else {
 +            Ok(ServiceStatus::NotInstalled)
 +        }
 +    }
 +}
++
 +#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 +#[derive(Debug)]
 +struct UnsupportedInstaller;
++
 +#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
 +impl ServiceInstaller for UnsupportedInstaller {
 +    fn install(
 +        &self,
 +        _config: &ServiceConfig,
 +        _runner: &mut dyn CommandRunner,
 +    ) -> Result<(), ServiceError> {
 +        Err(ServiceError::UnsupportedPlatform)
 +    }
++
 +    fn uninstall(&self, _runner: &mut dyn CommandRunner) -> Result<(), ServiceError> {
 +        Err(ServiceError::UnsupportedPlatform)
 +    }
++
 +    fn status(&self, _runner: &mut dyn CommandRunner) -> Result<ServiceStatus, ServiceError> {
 +        Err(ServiceError::UnsupportedPlatform)
 +    }
 +}
++
 +pub fn mac_launch_agent_plist(config: &ServiceConfig) -> String {
 +    let stdout = config.log_file.with_extension("out.log");
 +    let stderr = config.log_file.with_extension("err.log");
 +    format!(
 +        r#"<?xml version="1.0" encoding="UTF-8"?>
 +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 +<plist version="1.0">
 +<dict>
 +  <key>Label</key>
 +  <string>{}</string>
 +  <key>ProgramArguments</key>
 +  <array>
 +    <string>{}</string>
 +    <string>reminders</string>
 +    <string>run</string>
 +    <string>--events-file</string>
 +    <string>{}</string>
 +    <string>--state-file</string>
 +    <string>{}</string>
 +  </array>
 +  <key>RunAtLoad</key>
 +  <true/>
 +  <key>KeepAlive</key>
 +  <true/>
 +  <key>StandardOutPath</key>
 +  <string>{}</string>
 +  <key>StandardErrorPath</key>
 +  <string>{}</string>
 +</dict>
 +</plist>
 +"#,
 +        SERVICE_LABEL,
 +        xml_escape(&path_string(&config.executable)),
 +        xml_escape(&path_string(&config.events_file)),
 +        xml_escape(&path_string(&config.state_file)),
 +        xml_escape(&path_string(&stdout)),
 +        xml_escape(&path_string(&stderr)),
 +    )
 +}
++
 +pub fn linux_systemd_unit(config: &ServiceConfig) -> String {
 +    format!(
 +        "[Unit]\nDescription=rcal reminder notifications\n\n[Service]\nExecStart={} reminders run --events-file {} --state-file {}\nRestart=always\nRestartSec=5\n\n[Install]\nWantedBy=default.target\n",
 +        systemd_escape(&path_string(&config.executable)),
 +        systemd_escape(&path_string(&config.events_file)),
 +        systemd_escape(&path_string(&config.state_file)),
 +    )
 +}
++
 +pub fn windows_schtasks_create_args(config: &ServiceConfig) -> Vec<String> {
 +    let command = format!(
 +        "\"{}\" reminders run --events-file \"{}\" --state-file \"{}\"",
 +        path_string(&config.executable),
 +        path_string(&config.events_file),
 +        path_string(&config.state_file),
 +    );
 +    vec![
 +        "/Create".to_string(),
 +        "/TN".to_string(),
 +        WINDOWS_TASK_NAME.to_string(),
 +        "/SC".to_string(),
 +        "ONLOGON".to_string(),
 +        "/TR".to_string(),
 +        command,
 +        "/F".to_string(),
 +    ]
 +}
++
 +#[derive(Debug)]
 +pub enum ServiceError {
 +    CurrentExe { reason: String },
 +    MissingHome,
 +    UnsupportedPlatform,
 +    Write { path: PathBuf, reason: String },
 +    Command { program: String, reason: String },
 +}
++
 +impl fmt::Display for ServiceError {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        match self {
 +            Self::CurrentExe { reason } => {
 +                write!(f, "failed to locate current executable: {reason}")
 +            }
 +            Self::MissingHome => write!(f, "failed to locate a user home directory"),
 +            Self::UnsupportedPlatform => {
 +                write!(f, "reminder services are unsupported on this platform")
 +            }
 +            Self::Write { path, reason } => {
 +                write!(f, "failed to write {}: {reason}", path.display())
 +            }
 +            Self::Command { program, reason } => write!(f, "{program} failed: {reason}"),
 +        }
 +    }
 +}
++
 +impl Error for ServiceError {}
++
 +fn write_file(path: &Path, body: &str) -> Result<(), ServiceError> {
 +    if let Some(parent) = path.parent() {
 +        fs::create_dir_all(parent).map_err(|err| ServiceError::Write {
 +            path: parent.to_path_buf(),
 +            reason: err.to_string(),
 +        })?;
 +    }
++
 +    fs::write(path, body).map_err(|err| ServiceError::Write {
 +        path: path.to_path_buf(),
 +        reason: err.to_string(),
 +    })
 +}
++
 +fn home_dir() -> Result<PathBuf, ServiceError> {
 +    BaseDirs::new()
 +        .map(|dirs| dirs.home_dir().to_path_buf())
 +        .ok_or(ServiceError::MissingHome)
 +}
++
 +fn path_string(path: &Path) -> String {
 +    path.to_string_lossy().into_owned()
 +}
++
 +fn xml_escape(value: &str) -> String {
 +    value
 +        .replace('&', "&amp;")
 +        .replace('<', "&lt;")
 +        .replace('>', "&gt;")
 +        .replace('"', "&quot;")
 +        .replace('\'', "&apos;")
 +}
++
 +fn systemd_escape(value: &str) -> String {
 +    if value
 +        .chars()
 +        .all(|ch| !ch.is_whitespace() && ch != '\\' && ch != '"')
 +    {
 +        value.to_string()
 +    } else {
 +        format!("\"{}\"", value.replace('\\', "\\\\").replace('"', "\\\""))
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    fn config() -> ServiceConfig {
 +        ServiceConfig {
 +            executable: PathBuf::from("/usr/local/bin/rcal"),
 +            events_file: PathBuf::from("/tmp/rcal/events.json"),
 +            state_file: PathBuf::from("/tmp/rcal/state.json"),
 +            log_file: PathBuf::from("/tmp/rcal/reminders.log"),
 +        }
 +    }
++
 +    #[test]
 +    fn mac_launch_agent_contains_reminder_run_command() {
 +        let plist = mac_launch_agent_plist(&config());
++
 +        assert!(plist.contains("com.tenseleyflow.rcal.reminders"));
 +        assert!(plist.contains("<string>/usr/local/bin/rcal</string>"));
 +        assert!(plist.contains("<string>reminders</string>"));
 +        assert!(plist.contains("<string>--events-file</string>"));
 +    }
++
 +    #[test]
 +    fn linux_unit_contains_reminder_run_command() {
 +        let unit = linux_systemd_unit(&config());
++
 +        assert!(unit.contains("Description=rcal reminder notifications"));
 +        assert!(unit.contains("ExecStart=/usr/local/bin/rcal reminders run"));
 +        assert!(unit.contains("Restart=always"));
 +    }
++
 +    #[test]
 +    fn windows_task_command_contains_reminder_run_command() {
 +        let args = windows_schtasks_create_args(&config());
 +        let joined = args.join(" ");
++
 +        assert!(joined.contains("/Create"));
 +        assert!(joined.contains("rcal-reminders"));
 +        assert!(joined.contains("\"/usr/local/bin/rcal\" reminders run"));
 +    }
 +}