BAT-5 backward navigation is possible now

Author: enesify

src/main.rs

@@ -47,6 +47,10 @@ enum Commands {
     Done {
         id: String,
     },
+    /// Move one step back (Done → Doing, Doing → Todo)
+    Back {
+        id: String,
+    },
     /// Rename a task
     Edit {
         id: String,
@@ -169,6 +173,31 @@ fn main() -> Result<()> {
             println!("done {}", short_id(&id));
         }
 
+        Commands::Back { id } => {
+            let board = replay()?;
+            let id = resolve_task_id(&id, &board)?;
+            let task = board
+                .find_task(&id)
+                .context("task not found after resolve")?;
+            let to = task.column.back_from().context(
+                "task is already at Todo (nowhere to go back)",
+            )?;
+            let entry = WalEntry {
+                ts: now,
+                event: WalEvent::Move {
+                    id: id.clone(),
+                    to,
+                },
+            };
+            append(&entry)?;
+            let label = match to {
+                Column::Doing => "doing",
+                Column::Todo => "todo",
+                Column::Done => unreachable!("back_from never returns Done"),
+            };
+            println!("back -> {} {}", label, short_id(&id));
+        }
+
         Commands::Edit { id, title } => {
             let board = replay()?;
             let id = resolve_task_id(&id, &board)?;

src/state/mod.rs

@@ -39,15 +39,24 @@ pub fn replay_from(entries: impl IntoIterator<Item = WalEntry>) -> Board {
             }
             WalEvent::Move { id, to } => {
                 if let Some(task) = tasks.get_mut(&id) {
-                    if to == Column::Doing && task.started_at.is_none() {
-                        task.started_at = Some(entry.ts);
+                    match to {
+                        Column::Todo => {
+                            task.started_at = None;
+                            task.done_at = None;
+                            task.column = Column::Todo;
+                        }
+                        Column::Doing => {
+                            if task.started_at.is_none() {
+                                task.started_at = Some(entry.ts);
+                            }
+                            task.done_at = None;
+                            task.column = Column::Doing;
+                        }
+                        Column::Done => {
+                            task.done_at = Some(entry.ts);
+                            task.column = Column::Done;
+                        }
                     }
-                    if to == Column::Done {
-                        task.done_at = Some(entry.ts);
-                    } else {
-                        task.done_at = None;
-                    }
-                    task.column = to;
                 }
             }
             WalEvent::Edit { id, title } => {
@@ -135,6 +144,41 @@ mod tests {
         assert_eq!(board.done[0].id, id);
     }
 
+    #[test]
+    fn replay_move_to_todo_clears_started_at() {
+        let id = "01TESTTESTTESTTESTTEST".to_string();
+        let entries = vec![
+            WalEntry {
+                ts: Utc.with_ymd_and_hms(2026, 4, 1, 10, 0, 0).unwrap(),
+                event: WalEvent::Add {
+                    id: id.clone(),
+                    title: "t".to_string(),
+                    tags: vec![],
+                    day: "2026-04-01".to_string(),
+                },
+            },
+            WalEntry {
+                ts: Utc.with_ymd_and_hms(2026, 4, 2, 10, 0, 0).unwrap(),
+                event: WalEvent::Move {
+                    id: id.clone(),
+                    to: Column::Doing,
+                },
+            },
+            WalEntry {
+                ts: Utc.with_ymd_and_hms(2026, 4, 3, 10, 0, 0).unwrap(),
+                event: WalEvent::Move {
+                    id: id.clone(),
+                    to: Column::Todo,
+                },
+            },
+        ];
+        let board = replay_from(entries);
+        assert_eq!(board.todo.len(), 1);
+        assert_eq!(board.todo[0].id, id);
+        assert!(board.todo[0].started_at.is_none());
+        assert!(board.todo[0].done_at.is_none());
+    }
+
     #[test]
     fn daily_view_filters_done_only() {
         use chrono::Local;

src/ui/board.rs

@@ -71,7 +71,7 @@ pub fn draw(f: &mut Frame, app: &App) {
     );
 
     let hint = Paragraph::new(
-        " s start | d done | a toggle Done column | Tab column | g stats | q quit | add: tw add \"…\" ",
+        " s start | d done | b back | a Done view | Tab | g stats | q | tw add \"…\" ",
     )
     .style(Style::default().fg(Color::DarkGray))
     .block(Block::default().borders(Borders::ALL));

src/ui/mod.rs

@@ -140,6 +140,20 @@ pub fn run(initial_mode: DailyViewMode) -> Result<()> {
                             app.reload()?;
                         }
                     }
+                    KeyCode::Char('b') => {
+                        if let Some(id) = app.selected_task_id() {
+                            if let Some(task) = app.full_board.find_task(&id) {
+                                if let Some(to) = task.column.back_from() {
+                                    let now = chrono::Utc::now();
+                                    append(&WalEntry {
+                                        ts: now,
+                                        event: WalEvent::Move { id, to },
+                                    })?;
+                                    app.reload()?;
+                                }
+                            }
+                        }
+                    }
                     KeyCode::Char('a') => {
                         app.view_mode = match app.view_mode {
                             DailyViewMode::Day(_) => DailyViewMode::AllDone,

src/wal/event.rs

@@ -39,13 +39,24 @@ pub struct WalEntry {
     pub event: WalEvent,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Column {
     Todo,
     Doing,
     Done,
 }
 
+impl Column {
+    /// One step backward on the Todo → Doing → Done pipeline.
+    pub fn back_from(self) -> Option<Self> {
+        match self {
+            Column::Done => Some(Column::Doing),
+            Column::Doing => Some(Column::Todo),
+            Column::Todo => None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum TagAction {
     Add,