ADD: deprioritize command

src/main.rs

···
     /// task up.
     Tor,
 
-    /// Reprioritizes an arbitrary task to the top of the stack.
-    Reprioritize {
+    /// Prioritizes an arbitrary task to the top of the stack.
+    Prioritize {
         /// The [TSK-]ID to prioritize. If it exists, it is moved to the top of the stack.
+        #[command(flatten)]
+        task_id: TaskId,
+    },
+
+    /// Deprioritizes a task to the bottom of the stack.
+    Deprioritize {
+        /// The [TSK-]ID to deprioritize. If it exists, it is moved to the bottom of the stack.
         #[command(flatten)]
         task_id: TaskId,
     },
···
 fn main() {
     let cli = Cli::parse();
     let dir = cli.dir.unwrap_or(default_dir());
-    let result = match cli.command {
+    let var_name = match cli.command {
         Commands::Init => command_init(dir),
         Commands::Push { edit, body, title } => command_push(dir, edit, body, title),
         Commands::List { all, count } => command_list(dir, all, count),
···
         Commands::Find { args, full_id } => command_find(dir, full_id, args),
         Commands::Rot => Workspace::from_path(dir).unwrap().rot(),
         Commands::Tor => Workspace::from_path(dir).unwrap().tor(),
-        Commands::Reprioritize { task_id } => command_reprioritize(dir, task_id),
+        Commands::Prioritize { task_id } => command_prioritize(dir, task_id),
+        Commands::Deprioritize { task_id } => command_deprioritize(dir, task_id),
+
     };
+    let result = var_name;
     match result {
         Ok(_) => exit(0),
         Err(e) => {
···
     Ok(())
 }
 
-fn command_reprioritize(dir: PathBuf, task_id: TaskId) -> Result<()> {
-    Workspace::from_path(dir)?.reprioritize(task_id.into())
+fn command_prioritize(dir: PathBuf, task_id: TaskId) -> Result<()> {
+    Workspace::from_path(dir)?.prioritize(task_id.into())
+}
+
+fn command_deprioritize(dir: PathBuf, task_id: TaskId) -> Result<()> {
+    Workspace::from_path(dir)?.deprioritize(task_id.into())
 }
 
 fn command_show(dir: PathBuf, task_id: TaskId) -> Result<()> {

src/stack.rs

···
         self.all.push_front(item);
     }
 
+    pub fn push_back(&mut self, item: StackItem) {
+        self.all.push_back(item);
+    }
+
     pub fn pop(&mut self) -> Option<StackItem> {
         self.all.pop_front()
     }

src/workspace.rs

···
         }
     }
 
-    pub fn reprioritize(&self, identifier: TaskIdentifier) -> Result<()> {
+    pub fn prioritize(&self, identifier: TaskIdentifier) -> Result<()> {
         let id = self.resolve(identifier)?;
         let mut stack = self.read_stack()?;
         let index = &stack.iter().map(|i| i.id).position(|i| i == id);
···
             let prioritized_task = stack.remove(*index);
             // unwrap here is safe because we just searched for the index and know it exists
             stack.push(prioritized_task.unwrap());
+            stack.save()?;
+        }
+        Ok(())
+    }
+
+    pub fn deprioritize(&self, identifier: TaskIdentifier) -> Result<()> {
+        let id = self.resolve(identifier)?;
+        let mut stack = self.read_stack()?;
+        let index = &stack.iter().map(|i| i.id).position(|i| i == id);
+        if let Some(index) = index {
+            let deprioritized_task = stack.remove(*index);
+            // unwrap here is safe because we just searched for the index and know it exists
+            stack.push_back(deprioritized_task.unwrap());
             stack.save()?;
         }
         Ok(())