1 files changed, 0 insertions, 161 deletions
diff --git a/makima/daemon/src/task/state.rs b/makima/daemon/src/task/state.rs
deleted file mode 100644
index fe73de1..0000000
--- a/makima/daemon/src/task/state.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! Task state machine.
-
-use std::fmt;
-
-/// Task execution state.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum TaskState {
-    /// Task received, preparing overlay.
-    Initializing,
-    /// Overlay ready, starting container.
-    Starting,
-    /// Container running.
-    Running,
-    /// Container paused.
-    Paused,
-    /// Waiting for sibling or resource.
-    Blocked,
-    /// Task completed successfully.
-    Completed,
-    /// Task failed with error.
-    Failed,
-    /// Task interrupted by user.
-    Interrupted,
-}
-
-impl TaskState {
-    /// Check if a state transition is valid.
-    pub fn can_transition_to(&self, target: TaskState) -> bool {
-        use TaskState::*;
-
-        matches!(
-            (self, target),
-            // From Initializing
-            (Initializing, Starting)
-                | (Initializing, Failed)
-                | (Initializing, Interrupted)
-                // From Starting
-                | (Starting, Running)
-                | (Starting, Failed)
-                | (Starting, Interrupted)
-                // From Running
-                | (Running, Paused)
-                | (Running, Blocked)
-                | (Running, Completed)
-                | (Running, Failed)
-                | (Running, Interrupted)
-                // From Paused
-                | (Paused, Running)
-                | (Paused, Interrupted)
-                | (Paused, Failed)
-                // From Blocked
-                | (Blocked, Running)
-                | (Blocked, Failed)
-                | (Blocked, Interrupted)
-        )
-    }
-
-    /// Check if this state is terminal (no more transitions possible).
-    pub fn is_terminal(&self) -> bool {
-        matches!(
-            self,
-            TaskState::Completed | TaskState::Failed | TaskState::Interrupted
-        )
-    }
-
-    /// Check if the task is currently active (running or paused).
-    pub fn is_active(&self) -> bool {
-        matches!(
-            self,
-            TaskState::Initializing
-                | TaskState::Starting
-                | TaskState::Running
-                | TaskState::Paused
-                | TaskState::Blocked
-        )
-    }
-
-    /// Check if the task is running.
-    pub fn is_running(&self) -> bool {
-        matches!(self, TaskState::Running)
-    }
-
-    /// Convert to string for protocol messages.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            TaskState::Initializing => "initializing",
-            TaskState::Starting => "starting",
-            TaskState::Running => "running",
-            TaskState::Paused => "paused",
-            TaskState::Blocked => "blocked",
-            TaskState::Completed => "done",
-            TaskState::Failed => "failed",
-            TaskState::Interrupted => "interrupted",
-        }
-    }
-
-    /// Parse from string.
-    pub fn from_str(s: &str) -> Option<Self> {
-        match s.to_lowercase().as_str() {
-            "initializing" => Some(TaskState::Initializing),
-            "starting" => Some(TaskState::Starting),
-            "running" => Some(TaskState::Running),
-            "paused" => Some(TaskState::Paused),
-            "blocked" => Some(TaskState::Blocked),
-            "done" | "completed" => Some(TaskState::Completed),
-            "failed" => Some(TaskState::Failed),
-            "interrupted" => Some(TaskState::Interrupted),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for TaskState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl Default for TaskState {
-    fn default() -> Self {
-        TaskState::Initializing
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_valid_transitions() {
-        use TaskState::*;
-
-        // Valid transitions
-        assert!(Initializing.can_transition_to(Starting));
-        assert!(Starting.can_transition_to(Running));
-        assert!(Running.can_transition_to(Completed));
-        assert!(Running.can_transition_to(Paused));
-        assert!(Paused.can_transition_to(Running));
-
-        // Invalid transitions
-        assert!(!Completed.can_transition_to(Running));
-        assert!(!Failed.can_transition_to(Running));
-        assert!(!Running.can_transition_to(Initializing));
-    }
-
-    #[test]
-    fn test_terminal_states() {
-        assert!(TaskState::Completed.is_terminal());
-        assert!(TaskState::Failed.is_terminal());
-        assert!(TaskState::Interrupted.is_terminal());
-        assert!(!TaskState::Running.is_terminal());
-        assert!(!TaskState::Paused.is_terminal());
-    }
-
-    #[test]
-    fn test_parse() {
-        assert_eq!(TaskState::from_str("running"), Some(TaskState::Running));
-        assert_eq!(TaskState::from_str("done"), Some(TaskState::Completed));
-        assert_eq!(TaskState::from_str("invalid"), None);
-    }
-}