diff --git a/nag b/nag
index c11d701..b0f7a68 100755
--- a/nag
+++ b/nag
@@ -45,6 +45,7 @@ NAG_CMD="${NAG_CMD:-notify-send}"
 # Sound file to play when an alarm fires. Empty or missing file = no sound.
 NAG_SOUND="${NAG_SOUND-/usr/share/sounds/freedesktop/stereo/bell.oga}"
 _MUTE_FILE="${NAG_DIR}/mute"
+_SNOOZED_FILE="${NAG_DIR}/snoozed"
 
 # The default subcommand if no args are passed.
 NAG_DEFAULT="${NAG_DEFAULT:-list}"
@@ -211,23 +212,32 @@ _piped_input() {
 }
 
 # Usage:
-#   _confirm_action <verb> <count> <tag>
+#   _confirm_action <verb> <count> [<tag>]
 #
 # Prompts the user for confirmation before performing a bulk action on
-# tagged alarms. Skipped when -f (force/_YES) is set. In non-interactive
-# mode, prints a message asking the caller to pass -f.
+# alarms. When <tag> is provided, the prompt includes the tag name.
+# Skipped when -f (force/_YES) is set. In non-interactive mode, prints
+# a message asking the caller to pass -f.
 #
 # Exit / Error Status:
 #   0 (success, true)  If the action is confirmed.
 #   1 (error,  false)  If the action is denied or non-interactive without -f.
 _confirm_action() {
-  local _verb="${1}" _count="${2}" _tag="${3}"
+  local _verb="${1}" _count="${2}" _tag="${3:-}"
 
   (( _YES )) && return 0
 
+  local _desc
+  if [[ -n "${_tag}" ]]
+  then
+    _desc="${_count} alarm(s) tagged [${_tag}]"
+  else
+    _desc="${_count} alarm(s)"
+  fi
+
   if _interactive_input
   then
-    printf "%s %s alarm(s) tagged [%s]? [y/N] " "${_verb}" "${_count}" "${_tag}"
+    printf "%s %s? [y/N] " "${_verb}" "${_desc}"
     local _reply
     read -r _reply
     case "${_reply}" in
@@ -235,7 +245,7 @@ _confirm_action() {
       *)     return 1 ;;
     esac
   else
-    printf "%s %s alarm(s) tagged [%s]? Pass -f to confirm.\n" "${_verb}" "${_count}" "${_tag}"
+    printf "%s %s? Pass -f to confirm.\\n" "${_verb}" "${_desc}"
     return 1
   fi
 }
@@ -325,6 +335,8 @@ _SUBCOMMAND=""
 _SUBCOMMAND_ARGUMENTS=()
 _USE_DEBUG=0
 _YES=0
+_RAW_TIME=0
+_EPOCH_TIME=0
 
 while ((${#}))
 do
@@ -346,6 +358,12 @@ do
     -f)
       _YES=1
       ;;
+    --iso)
+      _RAW_TIME=1
+      ;;
+    --epoch)
+      _EPOCH_TIME=1
+      ;;
     *)
       # The first non-option argument is assumed to be the subcommand name.
       # All subsequent arguments are added to $_SUBCOMMAND_ARGUMENTS.
@@ -644,6 +662,176 @@ _is_muted() {
   return 1
 }
 
+# Usage:
+#   _is_snoozed <id>
+#
+# Description:
+#   Check whether an alarm ID is currently snoozed. If the entry has an
+#   expiry timestamp, it is only considered snoozed when the expiry is
+#   still in the future.
+#
+# Exit / Error Status:
+#   0 (success, true)  If the alarm is snoozed.
+#   1 (error,  false)  If the alarm is not snoozed.
+_is_snoozed() {
+  local _id="${1}"
+  [[ -f "${_SNOOZED_FILE}" ]] || return 1
+
+  local _now _entry
+  _now="$(date +%s)"
+
+  while IFS= read -r _entry || [[ -n "${_entry}" ]]
+  do
+    [[ -n "${_entry}" ]] || continue
+    local _entry_key="${_entry%%$'\t'*}"
+
+    [[ "${_entry_key}" == "${_id}" ]] || continue
+
+    # Check expiry if present.
+    if [[ "${_entry}" == *$'\t'* ]]
+    then
+      local _expiry="${_entry#*$'\t'}"
+      (( _expiry > _now )) && return 0
+    else
+      return 0
+    fi
+  done < "${_SNOOZED_FILE}"
+
+  return 1
+}
+
+# Usage:
+#   _sweep_expired_snoozes
+#
+# Description:
+#   Remove stale snooze entries: expired (past expiry timestamp) and
+#   orphaned (alarm ID no longer exists in _ALARMS). Expects _ALARMS
+#   to be populated via _read_alarms before calling.
+_sweep_expired_snoozes() {
+  [[ -f "${_SNOOZED_FILE}" ]] || return 0
+
+  local _now
+  _now="$(date +%s)"
+  local -a _keep=()
+  local _entry
+
+  while IFS= read -r _entry || [[ -n "${_entry}" ]]
+  do
+    [[ -n "${_entry}" ]] || continue
+
+    local _entry_id="${_entry%%$'\t'*}"
+
+    # Drop expired entries.
+    if [[ "${_entry}" == *$'\t'* ]]
+    then
+      local _expiry="${_entry#*$'\t'}"
+      (( _expiry <= _now )) && continue
+    fi
+
+    # Drop orphaned entries (alarm no longer exists).
+    local _exists=0 _line
+    for _line in "${_ALARMS[@]:-}"
+    do
+      [[ -n "${_line}" ]] || continue
+      [[ "${_line%%$'\t'*}" == "${_entry_id}" ]] && _exists=1 && break
+    done
+    (( _exists )) || continue
+
+    _keep+=("${_entry}")
+  done < "${_SNOOZED_FILE}"
+
+  if (( ${#_keep[@]} == 0 ))
+  then
+    rm -f "${_SNOOZED_FILE}"
+  else
+    printf "%s\n" "${_keep[@]}" > "${_SNOOZED_FILE}.tmp"
+    mv -f "${_SNOOZED_FILE}.tmp" "${_SNOOZED_FILE}"
+  fi
+}
+
+# Usage:
+#   _get_snooze_display <id>
+#
+# Description:
+#   Set REPLY to a display string for the given alarm ID's snooze status.
+#   Returns " (snoozed)" for indefinite snoozes, " (snoozed until <date>)"
+#   for timed snoozes, or "" if the alarm is not snoozed.
+_get_snooze_display() {
+  local _id="${1}"
+  REPLY=""
+  [[ -f "${_SNOOZED_FILE}" ]] || return 0
+
+  local _now _entry
+  _now="$(date +%s)"
+
+  while IFS= read -r _entry || [[ -n "${_entry}" ]]
+  do
+    [[ -n "${_entry}" ]] || continue
+    local _entry_key="${_entry%%$'\t'*}"
+
+    [[ "${_entry_key}" == "${_id}" ]] || continue
+
+    if [[ "${_entry}" == *$'\t'* ]]
+    then
+      local _expiry="${_entry#*$'\t'}"
+      if (( _expiry > _now ))
+      then
+        _format_time "${_expiry}"
+        REPLY=" (snoozed until ${REPLY})"
+      fi
+    else
+      REPLY=" (snoozed)"
+    fi
+    return 0
+  done < "${_SNOOZED_FILE}"
+}
+
+# Usage:
+#   _remove_snoozed_entry <key>
+#
+# Description:
+#   Remove the entry whose key matches <key> from the snoozed file.
+#   Returns 1 if no matching entry was found or the file does not exist.
+_remove_snoozed_entry() {
+  local _key="${1}"
+  [[ -f "${_SNOOZED_FILE}" ]] || return 1
+
+  local -a _keep=()
+  local _removed=0 _entry
+  while IFS= read -r _entry || [[ -n "${_entry}" ]]
+  do
+    [[ -n "${_entry}" ]] || continue
+    local _entry_key="${_entry%%$'\t'*}"
+    if [[ "${_entry_key}" == "${_key}" ]]
+    then
+      _removed=1
+    else
+      _keep+=("${_entry}")
+    fi
+  done < "${_SNOOZED_FILE}"
+
+  (( _removed )) || return 1
+
+  if (( ${#_keep[@]} == 0 ))
+  then
+    rm -f "${_SNOOZED_FILE}"
+  else
+    printf "%s\n" "${_keep[@]}" > "${_SNOOZED_FILE}.tmp"
+    mv -f "${_SNOOZED_FILE}.tmp" "${_SNOOZED_FILE}"
+  fi
+  return 0
+}
+
+# Usage:
+#   _cleanup_alarm_metadata <id>
+#
+# Description:
+#   Remove all metadata for an alarm ID (snoozed file entries).
+#   Called when an alarm is permanently removed.
+_cleanup_alarm_metadata() {
+  _remove_snoozed_entry "${1}" 2>/dev/null || true
+}
+
 # Usage:
 #   _tag_list <tag>
 #
@@ -697,7 +885,11 @@ _tag_list() {
 
     _tag_display=" [${_tags//,/, }]"
 
-    printf "[%s]%s %s%s — %s\\n" "${_id}" "${_tag_display}" "${_human_time}" "${_rule_display}" "${_message}"
+    local _snooze_display
+    _get_snooze_display "${_id}"
+    _snooze_display="${REPLY}"
+
+    printf "[%s]%s %s%s%s — %s\\n" "${_id}" "${_tag_display}" "${_human_time}" "${_rule_display}" "${_snooze_display}" "${_message}"
   done
 
   if (( ! _matched ))
@@ -718,6 +910,18 @@ _tag_list() {
 _format_time() {
   local _timestamp="${1}"
 
+  if (( _EPOCH_TIME ))
+  then
+    REPLY="${_timestamp}"
+    return
+  fi
+
+  if (( _RAW_TIME ))
+  then
+    REPLY="$(date -d "@${_timestamp}" "+%Y-%m-%d %H:%M:%S")"
+    return
+  fi
+
   # Single date call to get all needed components.
   local _date_parts
   _date_parts="$(date -d "@${_timestamp}" "+%-I|%M|%p|%Y-%m-%d|%A|%a %b %-d")"
@@ -768,12 +972,21 @@ _format_time() {
     _date_prefix="Tomorrow"
   elif (( _days_away <= 6 ))
   then
-    _date_prefix="This ${_day_name}"
+    _date_prefix="${_day_name}"
   elif (( _days_away <= 13 ))
   then
     _date_prefix="Next ${_day_name}"
   else
-    _date_prefix="${_short_date}"
+    local _alarm_year
+    _alarm_year="$(date -d "${_alarm_date}" +%Y)"
+    local _this_year
+    _this_year="$(date +%Y)"
+    if [[ "${_alarm_year}" != "${_this_year}" ]]
+    then
+      _date_prefix="${_short_date} ${_alarm_year}"
+    else
+      _date_prefix="${_short_date}"
+    fi
   fi
 
   REPLY="${_date_prefix}, ${_time_fmt}"
@@ -1020,6 +1233,87 @@ _first_occurrence() {
   fi
 }
 
+# Usage:
+#   _unskip_timestamp <timestamp> <rules>
+#
+# Description:
+#   Compute the next natural occurrence of a repeating alarm from now.
+#   Handles each rule type appropriately: day-of-week rules use today's
+#   date at alarm's time, month preserves day-of-month, year preserves
+#   month and day. For comma-separated rules, returns the earliest.
+_unskip_timestamp() {
+  local _timestamp="${1}" _rules="${2}"
+  local _now
+  _now="$(date +%s)"
+
+  local _time_of_day _alarm_day _alarm_month
+  _time_of_day="$(date -d "@${_timestamp}" +%H:%M:%S)"
+  _alarm_day="$(date -d "@${_timestamp}" +%-d)"
+  _alarm_month="$(date -d "@${_timestamp}" +%-m)"
+
+  local _earliest=""
+  local IFS=","
+  local _rule
+  for _rule in ${_rules}
+  do
+    local _candidate=""
+    case "${_rule}" in
+      hour)
+        _candidate="$((_now - (_now % 3600) + $(date -d "@${_timestamp}" +%s) % 3600))"
+        if (( _candidate <= _now )); then
+          _candidate=$((_candidate + 3600))
+        fi
+        ;;
+      day)
+        _candidate="$(date -d "$(date +%Y-%m-%d) ${_time_of_day}" +%s)"
+        if (( _candidate <= _now )); then
+          _candidate="$(date -d "$(date +%Y-%m-%d) + 1 day ${_time_of_day}" +%s)"
+        fi
+        ;;
+      month)
+        local _year_now _month_now
+        _year_now="$(date +%Y)"
+        _month_now="$(date +%-m)"
+        _candidate="$(date -d "$(printf "%04d-%02d-%02d %s" "${_year_now}" "${_month_now}" "${_alarm_day}" "${_time_of_day}")" +%s 2>/dev/null)" || _candidate=0
+        if (( _candidate <= _now )); then
+          if (( _candidate == 0 )); then
+            _candidate="$(date -d "$(date +%Y-%m-%d) ${_time_of_day}" +%s)"
+          fi
+          _candidate="$(_next_month "${_candidate}" "${_time_of_day}")"
+        fi
+        ;;
+      year)
+        local _year_now
+        _year_now="$(date +%Y)"
+        _candidate="$(date -d "$(printf "%04d-%02d-%02d %s" "${_year_now}" "${_alarm_month}" "${_alarm_day}" "${_time_of_day}")" +%s 2>/dev/null)" || _candidate=0
+        if (( _candidate <= _now )); then
+          if (( _candidate == 0 )); then
+            _candidate="$(date -d "$(date +%Y-%m-%d) ${_time_of_day}" +%s)"
+          fi
+          _candidate="$(_next_year "${_candidate}" "${_time_of_day}")"
+        fi
+        ;;
+      *)
+        # Day-of-week rules (weekday, weekend, mon-sun, week).
+        local _today_at_alarm_time
+        _today_at_alarm_time="$(date -d "$(date +%Y-%m-%d) ${_time_of_day}" +%s)"
+        _candidate="$(_first_occurrence "${_rule}" "${_today_at_alarm_time}")"
+        if (( _candidate <= _now )); then
+          _candidate="$(_next_occurrence "${_rule}" "${_candidate}")"
+        fi
+        ;;
+    esac
+
+    if [[ -n "${_candidate}" ]] && (( _candidate > 0 )); then
+      if [[ -z "${_earliest}" ]] || (( _candidate < _earliest )); then
+        _earliest="${_candidate}"
+      fi
+    fi
+  done
+
+  printf "%s" "${_earliest}"
+}
+
 # Usage:
 #   _timestamp_matches_rule <rules> <timestamp>
 #
@@ -1222,11 +1516,14 @@ Usage:
   ${_ME}                                     list all alarms
   ${_ME} <time> <message...>                 one-shot alarm
   ${_ME} every <rules> <time> <message...>   repeating alarm
-  ${_ME} stop <id|tag>                       delete alarm(s)
-  ${_ME} skip <id|tag>                       skip next occurrence(s)
+  ${_ME} stop <all|id|tag>                   delete alarm(s)
+  ${_ME} skip <all|id|tag>                   skip next occurrence(s)
+  ${_ME} unskip <all|id|tag>                 reset to next occurrence
   ${_ME} tag <id> <tags...>                  add tags to an alarm
   ${_ME} tag <tag>                           list alarms with a tag
   ${_ME} untag <id> <tags...>                remove tags from an alarm
+  ${_ME} snooze <all|id|tag> [<duration>]    snooze alarms
+  ${_ME} unsnooze <all|id|tag>               unsnooze alarms
   ${_ME} check                               check and fire due alarms
   ${_ME} mute <all|tag>                      mute alarm sounds
   ${_ME} unmute <all|tag>                    unmute alarm sounds
@@ -1235,9 +1532,11 @@ Usage:
   ${_ME} version                             show version
 
 Options:
-  -e  Edit alarms file directly.
-  -f  Skip all prompts.
-  -v  Show version.
+  -e         Edit alarms file directly.
+  -f         Skip all prompts.
+  --iso      Show times as YYYY-MM-DD HH:MM:SS.
+  --epoch    Show times as unix timestamps.
+  -v         Show version.
 
 Environment:
   NAG_DIR    Alarm storage directory (default: ~/.local/share/nag)
@@ -1322,7 +1621,11 @@ list() {
       _tag_display=""
     fi
 
-    printf "[%s]%s %s%s — %s\\n" "${_id}" "${_tag_display}" "${_human_time}" "${_rule_display}" "${_message}"
+    local _snooze_display
+    _get_snooze_display "${_id}"
+    _snooze_display="${REPLY}"
+
+    printf "[%s]%s %s%s%s — %s\\n" "${_id}" "${_tag_display}" "${_human_time}" "${_rule_display}" "${_snooze_display}" "${_message}"
   done
 }
 
@@ -1330,14 +1633,20 @@ list() {
 
 describe "stop" <<HEREDOC
 Usage:
-  ${_ME} stop <id|tag>
+  ${_ME} stop <all|id|tag>
 
 Description:
-  Stop an alarm by ID, or stop all alarms with a tag.
+  Stop an alarm by ID, or stop all alarms with a tag or "all".
 HEREDOC
 stop() {
   local _target="${1:-}"
-  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s stop <id|tag>\\n" "${_ME}"
+  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s stop <all|id|tag>\\n" "${_ME}"
+
+  if [[ "${_target}" == "all" ]]
+  then
+    _stop_all
+    return
+  fi
 
   if [[ ! "${_target}" =~ ^[0-9]+$ ]]
   then
@@ -1379,6 +1688,7 @@ stop() {
     _ALARMS=("${_new_alarms[@]}")
     _write_alarms
   fi
+  _cleanup_alarm_metadata "${_target}"
   _release_lock
 
   printf "Stopped alarm %s.\\n" "${_target}"
@@ -1413,25 +1723,10 @@ _stop_by_tag() {
     _exit_1 printf "No alarms tagged [%s].\\n" "${_tag}"
   fi
 
-  if (( ! _YES ))
+  if ! _confirm_action "Stop" "${#_matched[@]}" "${_tag}"
   then
-    if _interactive_input
-    then
-      printf "Stop %s alarm(s) tagged [%s]? [y/N] " "${#_matched[@]}" "${_tag}"
-      local _reply
-      read -r _reply
-      case "${_reply}" in
-        [yY]*) ;;
-        *)
-          _release_lock
-          return 0
-          ;;
-      esac
-    else
-      _release_lock
-      printf "Stop %s alarm(s) tagged [%s]? Pass -f to confirm.\\n" "${#_matched[@]}" "${_tag}"
-      return 0
-    fi
+    _release_lock
+    return 0
   fi
 
   if (( ${#_new_alarms[@]} == 0 ))
@@ -1442,7 +1737,6 @@ _stop_by_tag() {
     _ALARMS=("${_new_alarms[@]}")
     _write_alarms
   fi
-  _release_lock
 
   local _m
   for _m in "${_matched[@]}"
@@ -1450,24 +1744,64 @@ _stop_by_tag() {
     local _id _message
     _id="${_m%%$'\t'*}"
     _message="$(_get_alarm_field "${_m}" 5)"
+    _cleanup_alarm_metadata "${_id}"
     printf "Stopped [%s] %s\\n" "${_id}" "${_message}"
   done
+  _release_lock
+}
+
+_stop_all() {
+  _acquire_lock
+  _read_alarms
+
+  if (( ${#_ALARMS[@]} == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "No alarms to stop.\\n"
+  fi
+
+  if ! _confirm_action "Stop" "${#_ALARMS[@]}"
+  then
+    _release_lock
+    return 0
+  fi
+
+  local _line
+  for _line in "${_ALARMS[@]}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id _message
+    _id="${_line%%$'\t'*}"
+    _message="$(_get_alarm_field "${_line}" 5)"
+    _cleanup_alarm_metadata "${_id}"
+    printf "Stopped [%s] %s\\n" "${_id}" "${_message}"
+  done
+
+  _ALARMS=()
+  : > "${_ALARMS_FILE}"
+  _release_lock
 }
 
 # skip ########################################################################
 
 describe "skip" <<HEREDOC
 Usage:
-  ${_ME} skip <id|tag>
+  ${_ME} skip <all|id|tag>
 
 Description:
   Skip the next occurrence of a repeating alarm (reschedule without firing).
-  For one-shot alarms, this deletes them. With a tag, applies to all
+  For one-shot alarms, this deletes them. With a tag or "all", applies to all
   matching alarms.
 HEREDOC
 skip() {
   local _target="${1:-}"
-  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s skip <id|tag>\\n" "${_ME}"
+  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s skip <all|id|tag>\\n" "${_ME}"
+
+  if [[ "${_target}" == "all" ]]
+  then
+    _skip_all
+    return
+  fi
 
   if [[ ! "${_target}" =~ ^[0-9]+$ ]]
   then
@@ -1504,6 +1838,7 @@ skip() {
         _human_time="${REPLY}"
         printf "Skipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
       else
+        _cleanup_alarm_metadata "${_id}"
         printf "Stopped [%s] %s\\n" "${_id}" "${_message}"
       fi
     else
@@ -1555,25 +1890,10 @@ _skip_by_tag() {
     _exit_1 printf "No alarms tagged [%s].\\n" "${_tag}"
   fi
 
-  if (( ! _YES ))
+  if ! _confirm_action "Skip" "${_match_count}" "${_tag}"
   then
-    if _interactive_input
-    then
-      printf "Skip %s alarm(s) tagged [%s]? [y/N] " "${_match_count}" "${_tag}"
-      local _reply
-      read -r _reply
-      case "${_reply}" in
-        [yY]*) ;;
-        *)
-          _release_lock
-          return 0
-          ;;
-      esac
-    else
-      _release_lock
-      printf "Skip %s alarm(s) tagged [%s]? Pass -f to confirm.\\n" "${_match_count}" "${_tag}"
-      return 0
-    fi
+    _release_lock
+    return 0
   fi
 
   for _line in "${_ALARMS[@]:-}"
@@ -1597,6 +1917,7 @@ _skip_by_tag() {
         _human_time="${REPLY}"
         printf "Skipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
       else
+        _cleanup_alarm_metadata "${_id}"
         printf "Stopped [%s] %s\\n" "${_id}" "${_message}"
       fi
     else
@@ -1615,6 +1936,273 @@ _skip_by_tag() {
   _release_lock
 }
 
+_skip_all() {
+  _acquire_lock
+  _read_alarms
+
+  if (( ${#_ALARMS[@]} == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "No alarms to skip.\\n"
+  fi
+
+  if ! _confirm_action "Skip" "${#_ALARMS[@]}"
+  then
+    _release_lock
+    return 0
+  fi
+
+  local -a _new_alarms=()
+  local _line
+
+  for _line in "${_ALARMS[@]}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id _tags _timestamp _rule _message
+    _id="$(_get_alarm_field "${_line}" 1)"
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _timestamp="$(_get_alarm_field "${_line}" 3)"
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    _message="$(_get_alarm_field "${_line}" 5)"
+
+    if [[ -n "${_rule}" ]]
+    then
+      local _next_ts _human_time
+      _next_ts="$(_next_occurrence "${_rule}" "${_timestamp}")"
+      _new_alarms+=("$(printf "%s\t%s\t%s\t%s\t%s" "${_id}" "${_tags}" "${_next_ts}" "${_rule}" "${_message}")")
+      _format_time "${_next_ts}"
+      _human_time="${REPLY}"
+      printf "Skipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
+    else
+      _cleanup_alarm_metadata "${_id}"
+      printf "Stopped [%s] %s\\n" "${_id}" "${_message}"
+    fi
+  done
+
+  if (( ${#_new_alarms[@]} == 0 ))
+  then
+    _ALARMS=()
+    : > "${_ALARMS_FILE}"
+  else
+    _ALARMS=("${_new_alarms[@]}")
+    _write_alarms
+  fi
+  _release_lock
+}
+
+# unskip ######################################################################
+
+describe "unskip" <<HEREDOC
+Usage:
+  ${_ME} unskip <all|id|tag>
+
+Description:
+  Reset a repeating alarm to its next natural occurrence from today.
+  Reverses skips that pushed the alarm further into the future.
+  Only applies to repeating alarms. With a tag, applies to all
+  matching repeating alarms. With "all", resets every repeating alarm.
+HEREDOC
+unskip() {
+  local _target="${1:-}"
+  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s unskip <all|id|tag>\\n" "${_ME}"
+
+  if [[ "${_target}" == "all" ]]
+  then
+    _unskip_all
+    return
+  fi
+
+  if [[ ! "${_target}" =~ ^[0-9]+$ ]]
+  then
+    _unskip_by_tag "${_target}"
+    return
+  fi
+
+  _acquire_lock
+  _read_alarms
+
+  local -a _new_alarms=()
+  local _found=0 _line
+
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id _tags _timestamp _rule _message
+    _id="$(_get_alarm_field "${_line}" 1)"
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _timestamp="$(_get_alarm_field "${_line}" 3)"
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    _message="$(_get_alarm_field "${_line}" 5)"
+
+    if [[ "${_id}" == "${_target}" ]]
+    then
+      _found=1
+      if [[ -z "${_rule}" ]]
+      then
+        _release_lock
+        _exit_1 printf "Alarm %s is a one-shot (no rule to unskip).\\n" "${_target}"
+      fi
+
+      local _new_ts
+      _new_ts="$(_unskip_timestamp "${_timestamp}" "${_rule}")"
+
+      _new_alarms+=("$(printf "%s\t%s\t%s\t%s\t%s" "${_id}" "${_tags}" "${_new_ts}" "${_rule}" "${_message}")")
+
+      local _human_time
+      _format_time "${_new_ts}"
+      _human_time="${REPLY}"
+      printf "Unskipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
+    else
+      _new_alarms+=("${_line}")
+    fi
+  done
+
+  if (( ! _found ))
+  then
+    _release_lock
+    _exit_1 printf "No alarm with ID %s.\\n" "${_target}"
+  fi
+
+  _ALARMS=("${_new_alarms[@]}")
+  _write_alarms
+  _release_lock
+}
+
+_unskip_by_tag() {
+  local _tag="${1}"
+
+  _acquire_lock
+  _read_alarms
+
+  local _match_count=0 _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _tags _rule
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    if _alarm_has_tag "${_tags}" "${_tag}" && [[ -n "${_rule}" ]]
+    then
+      _match_count=$((_match_count + 1))
+    fi
+  done
+
+  if (( _match_count == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "No repeating alarms tagged [%s].\\n" "${_tag}"
+  fi
+
+  if ! _confirm_action "Unskip" "${_match_count}" "${_tag}"
+  then
+    _release_lock
+    return 0
+  fi
+
+  local -a _new_alarms=()
+
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id _tags _timestamp _rule _message
+    _id="$(_get_alarm_field "${_line}" 1)"
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _timestamp="$(_get_alarm_field "${_line}" 3)"
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    _message="$(_get_alarm_field "${_line}" 5)"
+
+    if _alarm_has_tag "${_tags}" "${_tag}" && [[ -n "${_rule}" ]]
+    then
+      local _new_ts
+      _new_ts="$(_unskip_timestamp "${_timestamp}" "${_rule}")"
+
+      _new_alarms+=("$(printf "%s\t%s\t%s\t%s\t%s" "${_id}" "${_tags}" "${_new_ts}" "${_rule}" "${_message}")")
+      local _human_time
+      _format_time "${_new_ts}"
+      _human_time="${REPLY}"
+      printf "Unskipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
+    else
+      _new_alarms+=("${_line}")
+    fi
+  done
+
+  _ALARMS=("${_new_alarms[@]}")
+  _write_alarms
+  _release_lock
+}
+
+_unskip_all() {
+  _acquire_lock
+  _read_alarms
+
+  local _match_count=0 _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _rule
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    [[ -n "${_rule}" ]] && _match_count=$((_match_count + 1))
+  done
+
+  if (( _match_count == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "No repeating alarms to unskip.\\n"
+  fi
+
+  if (( ! _YES ))
+  then
+    if _interactive_input
+    then
+      printf "Unskip all %s repeating alarm(s)? [y/N] " "${_match_count}"
+      local _reply
+      read -r _reply
+      case "${_reply}" in
+        [yY]*) ;;
+        *)
+          _release_lock
+          return 0
+          ;;
+      esac
+    else
+      _release_lock
+      printf "Unskip all %s repeating alarm(s)? Pass -f to confirm.\\n" "${_match_count}"
+      return 0
+    fi
+  fi
+
+  local -a _new_alarms=()
+
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id _tags _timestamp _rule _message
+    _id="$(_get_alarm_field "${_line}" 1)"
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _timestamp="$(_get_alarm_field "${_line}" 3)"
+    _rule="$(_get_alarm_field "${_line}" 4)"
+    _message="$(_get_alarm_field "${_line}" 5)"
+
+    if [[ -n "${_rule}" ]]
+    then
+      local _new_ts
+      _new_ts="$(_unskip_timestamp "${_timestamp}" "${_rule}")"
+
+      _new_alarms+=("$(printf "%s\t%s\t%s\t%s\t%s" "${_id}" "${_tags}" "${_new_ts}" "${_rule}" "${_message}")")
+      local _human_time
+      _format_time "${_new_ts}"
+      _human_time="${REPLY}"
+      printf "Unskipped [%s] %s — next: %s\\n" "${_id}" "${_message}" "${_human_time}"
+    else
+      _new_alarms+=("${_line}")
+    fi
+  done
+
+  _ALARMS=("${_new_alarms[@]}")
+  _write_alarms
+  _release_lock
+}
+
 # check #######################################################################
 
 describe "check" <<HEREDOC
@@ -1632,6 +2220,7 @@ check() {
 
   _acquire_lock
   _read_alarms
+  _sweep_expired_snoozes
 
   local -a _new_alarms=()
   local _now
@@ -1649,6 +2238,12 @@ check() {
     _rule="$(_get_alarm_field "${_line}" 4)"
     _message="$(_get_alarm_field "${_line}" 5)"
 
+    if _is_snoozed "${_id}"
+    then
+      _new_alarms+=("${_line}")
+      continue
+    fi
+
     if (( _timestamp <= _now ))
     then
       local _age=$(( _now - _timestamp ))
@@ -1872,6 +2467,315 @@ unmute() {
   fi
 }
 
+# snooze ######################################################################
+
+describe "snooze" <<HEREDOC
+Usage:
+  ${_ME} snooze <all|id|tag> [<duration>]
+
+Description:
+  Snooze alarms to prevent them from firing. Snoozed alarms stay in the
+  alarm file but are skipped by check. With "all", snoozes every alarm.
+  With an ID, snoozes that alarm. With a tag, snoozes all alarms with
+  that tag. Optional duration sets an automatic expiry.
+
+Examples:
+  ${_ME} snooze all              snooze everything
+  ${_ME} snooze 3               snooze alarm 3
+  ${_ME} snooze work            snooze all [work] alarms
+  ${_ME} snooze 3 "2 weeks"    snooze alarm 3 for 2 weeks
+  ${_ME} snooze all "July 15"  snooze everything until July 15
+HEREDOC
+_snooze_by_tag() {
+  local _tag="${1}" _duration_str="${2:-}"
+
+  _acquire_lock
+  _read_alarms
+
+  local _match_count=0 _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _tags
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _alarm_has_tag "${_tags}" "${_tag}" && _match_count=$((_match_count + 1))
+  done
+
+  if (( _match_count == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "No alarms tagged [%s].\\n" "${_tag}"
+  fi
+
+  if ! _confirm_action "Snooze" "${_match_count}" "${_tag}"
+  then
+    _release_lock
+    return 0
+  fi
+
+  _ensure_nag_dir
+
+  local _until_ts="" _until_date=""
+  if [[ -n "${_duration_str}" ]]
+  then
+    _until_ts="$(_parse_time "${_duration_str}")"
+    _format_time "${_until_ts}"
+    _until_date="${REPLY}"
+  fi
+
+  for _line in "${_ALARMS[@]}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _tags _id _message
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _alarm_has_tag "${_tags}" "${_tag}" || continue
+    _id="${_line%%$'\t'*}"
+    _message="$(_get_alarm_field "${_line}" 5)"
+    _remove_snoozed_entry "${_id}" 2>/dev/null || true
+    if [[ -n "${_until_ts}" ]]
+    then
+      printf "%s\t%s\\n" "${_id}" "${_until_ts}" >> "${_SNOOZED_FILE}"
+      printf "Snoozed [%s] %s until %s.\\n" "${_id}" "${_message}" "${_until_date}"
+    else
+      printf "%s\\n" "${_id}" >> "${_SNOOZED_FILE}"
+      printf "Snoozed [%s] %s.\\n" "${_id}" "${_message}"
+    fi
+  done
+
+  _release_lock
+}
+
+snooze() {
+  local _target="${1:-}"
+  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s snooze <all|id|tag> [<duration>]\\n" "${_ME}"
+
+  if [[ "${_target}" == "all" ]]
+  then
+    local _duration_str="${2:-}"
+    _acquire_lock
+    _read_alarms
+
+    if (( ${#_ALARMS[@]} == 0 ))
+    then
+      _release_lock
+      _exit_1 printf "No alarms to snooze.\\n"
+    fi
+
+    _ensure_nag_dir
+
+    local _until_ts="" _until_date=""
+    if [[ -n "${_duration_str}" ]]
+    then
+      _until_ts="$(_parse_time "${_duration_str}")"
+      _format_time "${_until_ts}"
+      _until_date="${REPLY}"
+    fi
+
+    local _line
+    for _line in "${_ALARMS[@]}"
+    do
+      [[ -n "${_line}" ]] || continue
+      local _id _message
+      _id="${_line%%$'\t'*}"
+      _message="$(_get_alarm_field "${_line}" 5)"
+      _remove_snoozed_entry "${_id}" 2>/dev/null || true
+      if [[ -n "${_until_ts}" ]]
+      then
+        printf "%s\t%s\\n" "${_id}" "${_until_ts}" >> "${_SNOOZED_FILE}"
+        printf "Snoozed [%s] %s until %s.\\n" "${_id}" "${_message}" "${_until_date}"
+      else
+        printf "%s\\n" "${_id}" >> "${_SNOOZED_FILE}"
+        printf "Snoozed [%s] %s.\\n" "${_id}" "${_message}"
+      fi
+    done
+
+    _release_lock
+    return
+  fi
+
+  if [[ ! "${_target}" =~ ^[0-9]+$ ]]
+  then
+    _snooze_by_tag "${_target}" "${2:-}"
+    return
+  fi
+
+  # Numeric: snooze by ID.
+  _acquire_lock
+  _read_alarms
+
+  local _found=0 _message="" _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id
+    _id="${_line%%$'\t'*}"
+    if [[ "${_id}" == "${_target}" ]]
+    then
+      _found=1
+      _message="$(_get_alarm_field "${_line}" 5)"
+      break
+    fi
+  done
+
+  if (( ! _found ))
+  then
+    _release_lock
+    _exit_1 printf "No alarm with ID %s.\\n" "${_target}"
+  fi
+
+  local _duration_str="${2:-}"
+  _ensure_nag_dir
+  _remove_snoozed_entry "${_target}" 2>/dev/null || true
+  if [[ -n "${_duration_str}" ]]
+  then
+    local _until_ts
+    _until_ts="$(_parse_time "${_duration_str}")"
+    printf "%s\t%s\\n" "${_target}" "${_until_ts}" >> "${_SNOOZED_FILE}"
+    _release_lock
+    _format_time "${_until_ts}"
+    printf "Snoozed [%s] %s until %s.\\n" "${_target}" "${_message}" "${REPLY}"
+  else
+    printf "%s\\n" "${_target}" >> "${_SNOOZED_FILE}"
+    _release_lock
+    printf "Snoozed [%s] %s.\\n" "${_target}" "${_message}"
+  fi
+}
+
+_unsnooze_by_tag() {
+  local _tag="${1}"
+
+  _acquire_lock
+  _read_alarms
+
+  # Find alarms with this tag whose IDs are in the snoozed file.
+  local -a _snoozed_ids=()
+  local _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _tags
+    _tags="$(_get_alarm_field "${_line}" 2)"
+    _alarm_has_tag "${_tags}" "${_tag}" || continue
+    local _id="${_line%%$'\t'*}"
+    # Check if this ID is in the snoozed file.
+    if [[ -f "${_SNOOZED_FILE}" ]]
+    then
+      local _entry
+      while IFS= read -r _entry || [[ -n "${_entry}" ]]
+      do
+        [[ -n "${_entry}" ]] || continue
+        local _key="${_entry%%$'\t'*}"
+        if [[ "${_key}" == "${_id}" ]]
+        then
+          _snoozed_ids+=("${_id}")
+          break
+        fi
+      done < "${_SNOOZED_FILE}"
+    fi
+  done
+
+  if (( ${#_snoozed_ids[@]} == 0 ))
+  then
+    _release_lock
+    _exit_1 printf "[%s] alarms are not snoozed.\\n" "${_tag}"
+  fi
+
+  if ! _confirm_action "Unsnooze" "${#_snoozed_ids[@]}" "${_tag}"
+  then
+    _release_lock
+    return 0
+  fi
+
+  local _id
+  for _id in "${_snoozed_ids[@]}"
+  do
+    _remove_snoozed_entry "${_id}"
+    local _message=""
+    for _line in "${_ALARMS[@]:-}"
+    do
+      [[ -n "${_line}" ]] || continue
+      local _aid="${_line%%$'\t'*}"
+      if [[ "${_aid}" == "${_id}" ]]
+      then
+        _message="$(_get_alarm_field "${_line}" 5)"
+        break
+      fi
+    done
+    printf "Unsnoozed [%s] %s.\\n" "${_id}" "${_message}"
+  done
+
+  _release_lock
+}
+
+# unsnooze ###################################################################
+
+describe "unsnooze" <<HEREDOC
+Usage:
+  ${_ME} unsnooze <all|id|tag>
+
+Description:
+  Unsnooze alarms. With "all", unsnoozes everything. With an ID,
+  unsnoozes that alarm. With a tag, unsnoozes all alarms with that tag.
+HEREDOC
+unsnooze() {
+  local _target="${1:-}"
+  [[ -n "${_target}" ]] || _exit_1 printf "Usage: %s unsnooze <all|id|tag>\\n" "${_ME}"
+
+  if [[ "${_target}" == "all" ]]
+  then
+    if [[ -f "${_SNOOZED_FILE}" ]]
+    then
+      _acquire_lock
+      rm -f "${_SNOOZED_FILE}"
+      _release_lock
+      printf "Unsnoozed all.\\n"
+    else
+      printf "Nothing is snoozed.\\n"
+    fi
+    return
+  fi
+
+  if [[ ! "${_target}" =~ ^[0-9]+$ ]]
+  then
+    _unsnooze_by_tag "${_target}"
+    return
+  fi
+
+  # Numeric: unsnooze by ID.
+  _acquire_lock
+  _read_alarms
+
+  local _found=0 _message="" _line
+  for _line in "${_ALARMS[@]:-}"
+  do
+    [[ -n "${_line}" ]] || continue
+    local _id
+    _id="${_line%%$'\t'*}"
+    if [[ "${_id}" == "${_target}" ]]
+    then
+      _found=1
+      _message="$(_get_alarm_field "${_line}" 5)"
+      break
+    fi
+  done
+
+  if (( ! _found ))
+  then
+    _release_lock
+    _exit_1 printf "No alarm with ID %s.\\n" "${_target}"
+  fi
+
+  if ! _remove_snoozed_entry "${_target}"
+  then
+    _release_lock
+    printf "Alarm %s is not snoozed.\\n" "${_target}"
+    return
+  fi
+
+  _release_lock
+  printf "Unsnoozed [%s] %s.\\n" "${_target}" "${_message}"
+}
+
 # edit ########################################################################
 
 describe "edit" <<HEREDOC
diff --git a/test/check.bats b/test/check.bats
index e6ff6e3..1d1cbab 100644
--- a/test/check.bats
+++ b/test/check.bats
@@ -124,3 +124,92 @@ SCRIPT
   _new_ts="$(cut -f3 "${NAG_DIR}/alarms" | head -1)"
   (( _new_ts > $(date +%s) ))
 }
+
+@test "check skips snoozed alarm and does not fire it" {
+  local _past_ts=$(( $(date +%s) - 60 ))
+  write_alarm "$(printf "1\t\t%s\t\tsnoozed alarm" "${_past_ts}")"
+  printf "1\\n" > "${NAG_DIR}/snoozed"
+
+  local _fired="${NAG_DIR}/fired"
+  export NAG_CMD="${NAG_DIR}/recorder"
+  cat > "${NAG_CMD}" <<'SCRIPT'
+#!/usr/bin/env bash
+printf "%s\n" "$2" >> "${NAG_DIR}/fired"
+SCRIPT
+  chmod +x "${NAG_CMD}"
+
+  run_nag check
+  [ "${status}" -eq 0 ]
+  [ ! -f "${_fired}" ]
+  [ -s "${NAG_DIR}/alarms" ]
+  grep -q "snoozed alarm" "${NAG_DIR}/alarms"
+}
+
+@test "check skips alarm snoozed with expiry" {
+  local _past_ts=$(( $(date +%s) - 60 ))
+  local _future_expiry=$(( $(date +%s) + 3600 ))
+  write_alarm "$(printf "1\t\t%s\t\tsnoozed alarm" "${_past_ts}")"
+  printf "1\t%s\\n" "${_future_expiry}" > "${NAG_DIR}/snoozed"
+
+  local _fired="${NAG_DIR}/fired"
+  export NAG_CMD="${NAG_DIR}/recorder"
+  cat > "${NAG_CMD}" <<'SCRIPT'
+#!/usr/bin/env bash
+printf "%s\n" "$2" >> "${NAG_DIR}/fired"
+SCRIPT
+  chmod +x "${NAG_CMD}"
+
+  run_nag check
+  [ "${status}" -eq 0 ]
+  [ ! -f "${_fired}" ]
+  [ -s "${NAG_DIR}/alarms" ]
+}
+
+@test "check sweeps expired snooze entries" {
+  local _future_ts=$(( $(date +%s) + 3600 ))
+  write_alarm "$(printf "1\t\t%s\t\talarm" "${_future_ts}")"
+  local _past_expiry=$(( $(date +%s) - 60 ))
+  printf "1\t%s\\n" "${_past_expiry}" > "${NAG_DIR}/snoozed"
+
+  run_nag check
+  [ "${status}" -eq 0 ]
+
+  if [ -f "${NAG_DIR}/snoozed" ]; then
+    [ ! -s "${NAG_DIR}/snoozed" ] || ! grep -q "^1" "${NAG_DIR}/snoozed"
+  fi
+}
+
+@test "check fires alarm after snooze expires" {
+  local _past_ts=$(( $(date +%s) - 60 ))
+  local _past_expiry=$(( $(date +%s) - 120 ))
+  write_alarm "$(printf "1\t\t%s\t\texpired snooze" "${_past_ts}")"
+  printf "1\t%s\\n" "${_past_expiry}" > "${NAG_DIR}/snoozed"
+
+  local _fired="${NAG_DIR}/fired"
+  export NAG_CMD="${NAG_DIR}/recorder"
+  cat > "${NAG_CMD}" <<'SCRIPT'
+#!/usr/bin/env bash
+printf "%s\n" "$2" >> "${NAG_DIR}/fired"
+SCRIPT
+  chmod +x "${NAG_CMD}"
+
+  run_nag check
+  [ "${status}" -eq 0 ]
+  grep -q "expired snooze" "${_fired}"
+}
+
+@test "check sweeps orphaned snooze entries for removed alarms" {
+  local _future_ts=$(( $(date +%s) + 3600 ))
+  write_alarm "$(printf "2\t\t%s\t\treal alarm" "${_future_ts}")"
+  # ID 1 does not exist in alarms, ID 2 does.
+  printf "1\\n" > "${NAG_DIR}/snoozed"
+  printf "2\\n" >> "${NAG_DIR}/snoozed"
+
+  run_nag check
+  [ "${status}" -eq 0 ]
+
+  # Orphan ID 1 should be swept, ID 2 should remain.
+  [ -f "${NAG_DIR}/snoozed" ]
+  ! grep -q "^1$" "${NAG_DIR}/snoozed"
+  grep -q "^2$" "${NAG_DIR}/snoozed"
+}
\ No newline at end of file
diff --git a/test/help.bats b/test/help.bats
index d504cd0..e748d4b 100644
--- a/test/help.bats
+++ b/test/help.bats
@@ -7,8 +7,8 @@ load test_helper
   [ "${status}" -eq 0 ]
   [[ "${output}" =~ "<time> <message...>" ]]
   [[ "${output}" =~ "every <rules> <time> <message...>" ]]
-  [[ "${output}" =~ "stop <id|tag>" ]]
-  [[ "${output}" =~ "skip <id|tag>" ]]
+  [[ "${output}" =~ "stop <all|id|tag>" ]]
+  [[ "${output}" =~ "skip <all|id|tag>" ]]
   [[ "${output}" =~ "check" ]]
   [[ "${output}" =~ "help [<subcommand>]" ]]
   [[ "${output}" =~ "Options:" ]]
@@ -39,14 +39,14 @@ load test_helper
   run_nag help stop
   [ "${status}" -eq 0 ]
   [[ "${output}" =~ "Usage:" ]]
-  [[ "${output}" =~ "stop <id|tag>" ]]
+  [[ "${output}" =~ "stop <all|id|tag>" ]]
 }
 
 @test "help skip shows skip usage" {
   run_nag help skip
   [ "${status}" -eq 0 ]
   [[ "${output}" =~ "Usage:" ]]
-  [[ "${output}" =~ "skip <id|tag>" ]]
+  [[ "${output}" =~ "skip <all|id|tag>" ]]
 }
 
 @test "help every shows every usage" {
diff --git a/test/list.bats b/test/list.bats
index afa0ddf..7eeb010 100644
--- a/test/list.bats
+++ b/test/list.bats
@@ -84,13 +84,13 @@ load test_helper
   [[ "${output}" =~ "Tomorrow,".*"tomorrow alarm" ]]
 }
 
-@test "list shows This <day> for alarm 3 days away" {
+@test "list shows <day> for alarm 3 days away" {
   local _ts=$(( $(date -d "$(date +%Y-%m-%d)" +%s) + 86400 * 3 + 43200 ))
   local _day="$(date -d "@${_ts}" +%A)"
   write_alarm "$(printf '1\t\t%s\t\tthis alarm' "${_ts}")"
   run_nag
   [ "${status}" -eq 0 ]
-  [[ "${output}" =~ "This ${_day},".*"this alarm" ]]
+  [[ "${output}" =~ "${_day},".*"this alarm" ]]
 }
 
 @test "list shows Next <day> for alarm 10 days away" {
@@ -110,3 +110,61 @@ load test_helper
   [ "${status}" -eq 0 ]
   [[ "${output}" =~ "${_date},".*"far alarm" ]]
 }
+
+@test "list shows (snoozed) for indefinitely snoozed alarm" {
+  run_nag at "tomorrow 3pm" "take a break"
+  printf "1\\n" > "${NAG_DIR}/snoozed"
+  run_nag
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "(snoozed)" ]]
+  [[ "${output}" =~ "take a break" ]]
+}
+
+@test "list shows (snoozed until DATE) for timed snooze" {
+  run_nag at "tomorrow 3pm" "take a break"
+  local _expiry_ts=$(( $(date +%s) + 86400 * 7 ))
+  printf "1\t%s\\n" "${_expiry_ts}" > "${NAG_DIR}/snoozed"
+  run_nag
+  [ "${status}" -eq 0 ]
+  # Should use the same format as list dates (e.g. "Next Monday, 3pm").
+  [[ "${output}" =~ "snoozed until " ]]
+  [[ "${output}" =~ "am)" ]] || [[ "${output}" =~ "pm)" ]]
+}
+
+@test "list shows year for alarm in a different year" {
+  local _next_year=$(( $(date +%Y) + 1 ))
+  local _ts
+  _ts="$(date -d "${_next_year}-06-15 14:00:00" +%s)"
+  write_alarm "$(printf '1\t\t%s\t\tnext year alarm' "${_ts}")"
+  run_nag
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "${_next_year}" ]]
+  [[ "${output}" =~ "next year alarm" ]]
+}
+
+@test "list does not show (snoozed) for unsnoozed alarm" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag
+  [ "${status}" -eq 0 ]
+  [[ ! "${output}" =~ "snoozed" ]]
+}
+
+@test "--iso flag shows YYYY-MM-DD HH:MM:SS format" {
+  local _ts=$(( $(date -d "$(date +%Y-%m-%d)" +%s) + 86400 + 54000 ))
+  write_alarm "$(printf '1\t\t%s\t\traw alarm' "${_ts}")"
+  local _expected
+  _expected="$(date -d "@${_ts}" "+%Y-%m-%d %H:%M:%S")"
+  run "${_NAG}" -f --iso
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "${_expected}" ]]
+  [[ "${output}" =~ "raw alarm" ]]
+}
+
+@test "--epoch flag shows unix timestamps" {
+  local _ts=$(( $(date -d "$(date +%Y-%m-%d)" +%s) + 86400 + 54000 ))
+  write_alarm "$(printf '1\t\t%s\t\tepoch alarm' "${_ts}")"
+  run "${_NAG}" -f --epoch
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "${_ts}" ]]
+  [[ "${output}" =~ "epoch alarm" ]]
+}
diff --git a/test/skip.bats b/test/skip.bats
index 915a8e1..a83288f 100644
--- a/test/skip.bats
+++ b/test/skip.bats
@@ -61,3 +61,41 @@ load test_helper
   run "${_NAG}" -f skip work
   [ "${status}" -eq 1 ]
 }
+
+@test "skip all reschedules repeating and deletes one-shots" {
+  run_nag at "tomorrow 3pm" "one-shot"
+  run_nag every day "tomorrow 3pm" "daily task"
+  run "${_NAG}" -f skip all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Stopped" ]]
+  [[ "${output}" =~ "Skipped" ]]
+  # One-shot removed, repeating kept.
+  [ -s "${NAG_DIR}/alarms" ]
+  ! grep -q "one-shot" "${NAG_DIR}/alarms"
+  grep -q "daily task" "${NAG_DIR}/alarms"
+}
+
+@test "skip all requires -f" {
+  run_nag at "tomorrow 3pm" "test"
+  run "${_NAG}" skip all < /dev/null
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Skip" ]]
+  [[ "${output}" =~ "-f" ]]
+}
+
+@test "skip all with no alarms fails" {
+  run "${_NAG}" -f skip all
+  [ "${status}" -eq 1 ]
+}
+
+@test "skip one-shot cleans up snoozed metadata" {
+  run_nag at "tomorrow 3pm" "one-shot"
+  run_nag snooze 1
+  [ -f "${NAG_DIR}/snoozed" ]
+  run_nag skip 1
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Stopped" ]]
+  if [ -f "${NAG_DIR}/snoozed" ]; then
+    ! grep -q "^1" "${NAG_DIR}/snoozed"
+  fi
+}
diff --git a/test/snooze.bats b/test/snooze.bats
new file mode 100644
index 0000000..d648eb8
--- /dev/null
+++ b/test/snooze.bats
@@ -0,0 +1,189 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+@test "snooze by ID creates entry in snoozed file" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snoozed [1]" ]]
+  [ -f "${NAG_DIR}/snoozed" ]
+  grep -q "^1$" "${NAG_DIR}/snoozed"
+}
+
+@test "snooze by ID shows alarm message in output" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1
+  [[ "${output}" =~ "take a break" ]]
+}
+
+@test "snooze with nonexistent ID fails" {
+  run_nag snooze 99
+  [ "${status}" -eq 1 ]
+}
+
+@test "snooze with no args fails" {
+  run_nag snooze
+  [ "${status}" -eq 1 ]
+}
+
+@test "snooze all creates entries for all alarm IDs" {
+  run_nag at "tomorrow 3pm" "first"
+  run_nag at "tomorrow 4pm" "second"
+  run_nag snooze all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snoozed [1]" ]]
+  [[ "${output}" =~ "Snoozed [2]" ]]
+  [ -f "${NAG_DIR}/snoozed" ]
+  grep -q "^1$" "${NAG_DIR}/snoozed"
+  grep -q "^2$" "${NAG_DIR}/snoozed"
+}
+
+@test "snooze all with duration sets expiry for each alarm" {
+  run_nag at "tomorrow 3pm" "first"
+  run_nag at "tomorrow 4pm" "second"
+  run_nag snooze all "tomorrow"
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "until" ]]
+  grep -q "^1"$'\t' "${NAG_DIR}/snoozed"
+  grep -q "^2"$'\t' "${NAG_DIR}/snoozed"
+}
+
+@test "snooze by tag creates entries for matching alarm IDs" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze work
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snoozed [1]" ]]
+  grep -q "^1$" "${NAG_DIR}/snoozed"
+  ! grep -q "^work" "${NAG_DIR}/snoozed"
+}
+
+@test "snooze by tag requires -f" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run "${_NAG}" snooze work < /dev/null
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snooze" ]]
+  [[ "${output}" =~ "-f" ]]
+}
+
+@test "snooze by tag with no matching alarms fails" {
+  run_nag at "tomorrow 3pm" "test alarm"
+  run "${_NAG}" -f snooze nonexistent
+  [ "${status}" -eq 1 ]
+}
+
+@test "snooze by ID with duration sets expiry" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1 "tomorrow"
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snoozed [1]" ]]
+  [[ "${output}" =~ "until" ]]
+  local _line
+  _line="$(cat "${NAG_DIR}/snoozed")"
+  [[ "${_line}" == 1$'\t'* ]]
+}
+
+@test "snooze by tag with duration sets expiry for matching IDs" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze work "tomorrow"
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Snoozed [1]" ]]
+  [[ "${output}" =~ "until" ]]
+  grep -q "^1"$'\t' "${NAG_DIR}/snoozed"
+  ! grep -q "^work" "${NAG_DIR}/snoozed"
+}
+
+@test "unsnooze by ID removes entry from snoozed file" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1
+  run_nag unsnooze 1
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unsnoozed [1]" ]]
+  ! grep -q "^1" "${NAG_DIR}/snoozed" 2>/dev/null
+}
+
+@test "unsnooze all removes snoozed file" {
+  run_nag at "tomorrow 3pm" "test alarm"
+  run_nag snooze all
+  run_nag unsnooze all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unsnoozed all" ]]
+  [ ! -f "${NAG_DIR}/snoozed" ]
+}
+
+@test "unsnooze all when nothing snoozed says so" {
+  run_nag unsnooze all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Nothing is snoozed" ]]
+}
+
+@test "unsnooze with no args fails" {
+  run_nag unsnooze
+  [ "${status}" -eq 1 ]
+}
+
+@test "unsnooze by tag removes snoozed entries for matching alarms" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze work
+  run_nag unsnooze work
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unsnoozed [1]" ]]
+  ! grep -q "^1" "${NAG_DIR}/snoozed" 2>/dev/null
+}
+
+@test "unsnooze by tag requires -f" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze work
+  run "${_NAG}" unsnooze work < /dev/null
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unsnooze" ]]
+  [[ "${output}" =~ "-f" ]]
+}
+
+@test "unsnooze nonexistent ID fails" {
+  run_nag unsnooze 99
+  [ "${status}" -eq 1 ]
+}
+
+@test "unsnooze tag with no snoozed alarms fails" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run "${_NAG}" -f unsnooze work
+  [ "${status}" -eq 1 ]
+  [[ "${output}" =~ "not snoozed" ]]
+}
+
+@test "snooze replaces existing entry instead of duplicating" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1
+  run_nag snooze 1
+  [ "${status}" -eq 0 ]
+  [ "$(grep -c "^1" "${NAG_DIR}/snoozed")" -eq 1 ]
+}
+
+@test "snooze by tag does not duplicate already-snoozed IDs" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze 1
+  run_nag snooze work
+  [ "${status}" -eq 0 ]
+  [ "$(grep -c "^1" "${NAG_DIR}/snoozed")" -eq 1 ]
+}
+
+@test "unsnooze by tag removes ID-snoozed alarms with that tag" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze 1
+  run_nag snooze work
+  run_nag unsnooze work
+  [ "${status}" -eq 0 ]
+  # Alarm should be fully unsnoozed, no entries left
+  if [ -f "${NAG_DIR}/snoozed" ]; then
+    [ ! -s "${NAG_DIR}/snoozed" ] || ! grep -q "^1" "${NAG_DIR}/snoozed"
+  fi
+}
diff --git a/test/stop.bats b/test/stop.bats
index 1b5e9ae..90d211a 100644
--- a/test/stop.bats
+++ b/test/stop.bats
@@ -61,3 +61,60 @@ load test_helper
   run "${_NAG}" -f stop work
   [ "${status}" -eq 1 ]
 }
+
+@test "stop all removes all alarms with confirmation" {
+  run_nag at "tomorrow 3pm" "first"
+  run_nag at "tomorrow 4pm" "second"
+  run "${_NAG}" -f stop all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Stopped" ]]
+  run_nag
+  [[ "${output}" =~ "Nothing to nag about" ]]
+}
+
+@test "stop all requires -f" {
+  run_nag at "tomorrow 3pm" "test"
+  run "${_NAG}" stop all < /dev/null
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Stop" ]]
+  [[ "${output}" =~ "-f" ]]
+  [ -s "${NAG_DIR}/alarms" ]
+}
+
+@test "stop all with no alarms fails" {
+  run "${_NAG}" -f stop all
+  [ "${status}" -eq 1 ]
+}
+
+@test "stop by ID cleans up snoozed metadata" {
+  run_nag at "tomorrow 3pm" "take a break"
+  run_nag snooze 1
+  [ -f "${NAG_DIR}/snoozed" ]
+  run_nag stop 1
+  [ "${status}" -eq 0 ]
+  if [ -f "${NAG_DIR}/snoozed" ]; then
+    ! grep -q "^1" "${NAG_DIR}/snoozed"
+  fi
+}
+
+@test "stop by tag cleans up snoozed metadata" {
+  run_nag at "tomorrow 3pm" "work task"
+  run_nag tag 1 work
+  run_nag snooze 1
+  [ -f "${NAG_DIR}/snoozed" ]
+  run "${_NAG}" -f stop work
+  [ "${status}" -eq 0 ]
+  if [ -f "${NAG_DIR}/snoozed" ]; then
+    ! grep -q "^1" "${NAG_DIR}/snoozed"
+  fi
+}
+
+@test "stop all cleans up snoozed metadata" {
+  run_nag at "tomorrow 3pm" "first"
+  run_nag at "tomorrow 4pm" "second"
+  run_nag snooze all
+  [ -f "${NAG_DIR}/snoozed" ]
+  run "${_NAG}" -f stop all
+  [ "${status}" -eq 0 ]
+  [ ! -f "${NAG_DIR}/snoozed" ] || [ ! -s "${NAG_DIR}/snoozed" ]
+}
diff --git a/test/unskip.bats b/test/unskip.bats
new file mode 100644
index 0000000..1c9e100
--- /dev/null
+++ b/test/unskip.bats
@@ -0,0 +1,181 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+@test "unskip resets repeating alarm to next natural occurrence" {
+  run_nag every day "tomorrow 3pm" "daily task"
+  run_nag skip 1
+  run_nag skip 1
+  local _skipped_ts
+  _skipped_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+
+  run_nag unskip 1
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unskipped [1]" ]]
+  [[ "${output}" =~ "daily task" ]]
+
+  local _new_ts
+  _new_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+  (( _new_ts < _skipped_ts ))
+  (( _new_ts > $(date +%s) ))
+}
+
+@test "unskip one-shot alarm fails" {
+  run_nag at "tomorrow 3pm" "one-shot"
+  run_nag unskip 1
+  [ "${status}" -eq 1 ]
+  [[ "${output}" =~ "one-shot" ]]
+}
+
+@test "unskip with nonexistent ID fails" {
+  run_nag unskip 99
+  [ "${status}" -eq 1 ]
+}
+
+@test "unskip without args fails" {
+  run_nag unskip
+  [ "${status}" -eq 1 ]
+}
+
+@test "unskip by tag requires -f" {
+  run_nag every day "tomorrow 3pm" "daily work"
+  run_nag tag 1 work
+  run_nag skip 1
+  run "${_NAG}" unskip work < /dev/null
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unskip" ]]
+  [[ "${output}" =~ "-f" ]]
+}
+
+@test "unskip by tag with -f resets matching alarms" {
+  run_nag every day "tomorrow 3pm" "daily work"
+  run_nag tag 1 work
+  run_nag skip 1
+  run_nag skip 1
+  local _skipped_ts
+  _skipped_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+
+  run "${_NAG}" -f unskip work
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unskipped" ]]
+
+  local _new_ts
+  _new_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+  (( _new_ts < _skipped_ts ))
+}
+
+@test "unskip by tag with no repeating alarms fails" {
+  run_nag at "tomorrow 3pm" "one-shot"
+  run_nag tag 1 work
+  run "${_NAG}" -f unskip work
+  [ "${status}" -eq 1 ]
+  [[ "${output}" =~ "No repeating" ]]
+}
+
+@test "unskip by tag with no matching tag fails" {
+  run_nag every day "tomorrow 3pm" "daily task"
+  run "${_NAG}" -f unskip nonexistent
+  [ "${status}" -eq 1 ]
+}
+
+@test "unskip all resets all repeating alarms" {
+  run_nag every day "tomorrow 3pm" "daily one"
+  run_nag every day "tomorrow 4pm" "daily two"
+  run_nag skip 1
+  run_nag skip 1
+  run_nag skip 2
+  run_nag skip 2
+
+  run "${_NAG}" -f unskip all
+  [ "${status}" -eq 0 ]
+  [[ "${output}" =~ "Unskipped [1]" ]]
+  [[ "${output}" =~ "Unskipped [2]" ]]
+}
+
+@test "unskip yearly alarm preserves month and day" {
+  # Create a yearly alarm for a future date in the current year.
+  local _target_month=$(( $(date +%-m) + 1 ))
+  local _target_year=$(date +%Y)
+  if (( _target_month > 12 )); then
+    _target_month=1
+    _target_year=$((_target_year + 1))
+  fi
+  local _target_date="$(printf "%04d-%02d-15 14:00:00" "${_target_year}" "${_target_month}")"
+  local _target_ts="$(date -d "${_target_date}" +%s)"
+
+  # Write alarm directly: yearly rule, timestamp in the future.
+  write_alarm "$(printf "1\t\t%s\tyear\tyearly event" "${_target_ts}")"
+
+  # Skip it twice to push it 2 years out.
+  run_nag skip 1
+  run_nag skip 1
+  local _skipped_ts
+  _skipped_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+
+  run_nag unskip 1
+  [ "${status}" -eq 0 ]
+
+  # Should come back to the original month/day, not today's date.
+  local _new_ts _new_month _new_day
+  _new_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+  _new_month="$(date -d "@${_new_ts}" +%-m)"
+  _new_day="$(date -d "@${_new_ts}" +%-d)"
+  [ "${_new_month}" -eq "${_target_month}" ]
+  [ "${_new_day}" -eq 15 ]
+  (( _new_ts > $(date +%s) ))
+  (( _new_ts < _skipped_ts ))
+}
+
+@test "unskip monthly alarm preserves day of month" {
+  # Create a monthly alarm for the 20th at 2pm.
+  local _now_day=$(date +%-d)
+  local _target_day=20
+  local _target_ts
+
+  # If today is past the 20th, set it for the 20th next month.
+  if (( _now_day >= _target_day )); then
+    _target_ts="$(date -d "$(date +%Y-%m-${_target_day}) + 1 month 14:00:00" +%s)"
+  else
+    _target_ts="$(date -d "$(date +%Y-%m-${_target_day}) 14:00:00" +%s)"
+  fi
+
+  write_alarm "$(printf "1\t\t%s\tmonth\tmonthly event" "${_target_ts}")"
+
+  run_nag skip 1
+  run_nag skip 1
+  local _skipped_ts
+  _skipped_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+
+  run_nag unskip 1
+  [ "${status}" -eq 0 ]
+
+  local _new_ts _new_day
+  _new_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+  _new_day="$(date -d "@${_new_ts}" +%-d)"
+  [ "${_new_day}" -eq "${_target_day}" ]
+  (( _new_ts > $(date +%s) ))
+  (( _new_ts < _skipped_ts ))
+}
+
+@test "unskip weekday alarm lands on a weekday" {
+  run_nag every weekday "tomorrow 9am" "standup"
+  run_nag skip 1
+  run_nag skip 1
+  run_nag skip 1
+
+  run_nag unskip 1
+  [ "${status}" -eq 0 ]
+
+  local _new_ts _dow
+  _new_ts="$(cut -f3 "${NAG_DIR}/alarms")"
+  _dow="$(date -d "@${_new_ts}" +%u)"
+  # 1-5 = weekday
+  (( _dow >= 1 && _dow <= 5 ))
+  (( _new_ts > $(date +%s) ))
+}
+
+@test "unskip all with no repeating alarms fails" {
+  run_nag at "tomorrow 3pm" "one-shot"
+  run "${_NAG}" -f unskip all
+  [ "${status}" -eq 1 ]
+}