Index: flowtimer/Phase.py
===================================================================
--- flowtimer/Phase.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ flowtimer/Phase.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -47,5 +47,5 @@
         """
 
-        return ("-->" + self.title + "\nTicks left=" +
+        return ("Title:" + self.title + "\nTicks left=" +
                 str(self._ticks_left) + "\n" + str(self._state) + "\n")
 
@@ -54,5 +54,8 @@
 
     def abort(self):
-        self._state = "finished"
+        self._state = "aborted"
+
+    def aborted(self):
+        return self.state == "aborted"
 
     def start(self):
@@ -70,6 +73,6 @@
         # return self.time_left > 0
 
-    def finished(self):
-        return self._state == "finished"
+    def completed(self):
+        return self._state == "completed"
 
     def paused(self):
@@ -81,5 +84,5 @@
         if result <= 0:
             self._ticks_left = 0
-            self._state = "finished"
+            self._state = "completed"
         else:
             self._ticks_left = result
Index: flowtimer/RecurringPhaseSequence.py
===================================================================
--- flowtimer/RecurringPhaseSequence.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ flowtimer/RecurringPhaseSequence.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -20,6 +20,5 @@
     def default_json_string(cls):
         return json.dumps({"title": "default",
-                           "phase_list": [{"title": "Huddle", "initial_ticks": 10},
-                                          {"title": "Tasking", "initial_ticks": 5},
+                           "phase_list": [{"title": "Tasking", "initial_ticks": 5},
                                           {"title": "Work", "initial_ticks": 45},
                                           {"title": "Break", "initial_ticks": 15}],
@@ -46,4 +45,7 @@
     def title(self):
         return self._title
+
+    def __str__(self):
+        return ("Sequence title:" + self.title + "\n" + str(self.current_phase))
 
     def is_sequence(self):
@@ -72,12 +74,12 @@
             sum([each.ticks_left for each in self.upcoming_phases_in_pass()]))
 
-    def finished(self):
+    def completed(self):
         return ((self.passes_left < 1) and
                 (not self.upcoming_phases_in_pass() and
-                 self.current_phase.finished()))
+                 self.current_phase.completed()))
 
     def abort(self):
         self.current_phase.abort()
-        self.state = "finished"
+        self.state = "aborted"
 
     def start(self):
@@ -99,21 +101,35 @@
                 self.current_phase = self.phase_list[0]
 
+    def advance_to_next_phase(self):
+        current_index = self.current_phase_number()
+        if current_index < len(self.phase_list) - 1:
+            # Move to the next phase in the sequence
+            self.current_phase.reset()
+            self.current_phase = self.phase_list[current_index + 1]
+        else:
+            # Completed a full sequence; check if more repetitions are needed
+            self.passes_left -= 1
+            if self.passes_left < 1:
+                self.state = "completed"
+            else:
+                self.current_phase.reset()
+                self.current_phase = self.phase_list[0]  # Reset to the first phase
+
     def tick(self, ticks):
-        if not self.finished():
+        print("Before tick")
+        print(self.current_phase)
+        print("Tick:", ticks)
+        if not self.completed():
             result = self.current_phase.tick(ticks)
-            if self.current_phase.finished():
-                if self.upcoming_phases_in_pass():
-                    self.current_phase.reset()
-                    self.current_phase = self.upcoming_phases_in_pass()[0]
-                    self.current_phase.start()
-                    self.tick(abs(result))
-                    return True
-                self.passes_left -= 1
-                if self.finished():
-                    self.state = "finished"
-                else:
-                    self.current_phase.reset()
-                    self.current_phase = self.phase_list[0]
-        return True
+            print("Result", result, "\n")
+            if self.current_phase.completed():
+                print(self.current_phase.title, "Phase Completed")
+                self.advance_to_next_phase()
+                print("Advanced to", self.current_phase, "\n")
+                result = self.tick(abs(result))
+                return
+        if self.completed():
+            self.advance_to_next_phase()
+        print("Passes left:", self.passes_left)
 
     def unrolled(self):
Index: flowtimer/Schedule.py
===================================================================
--- flowtimer/Schedule.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ flowtimer/Schedule.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -6,4 +6,5 @@
 I represent a Schedule consisting of blocks. Blocks can be a single phase or
 a sequence of phases.
+There are 6 states a Schedule can be in: initial, running, completed, aborted, paused, terminated.
 """
 
@@ -72,11 +73,11 @@
     def to_json(self):
         def serialize_block(block):
-            if not block.is_sequence:
+            if not block.is_sequence():
                 return {"type": "Phase", "title": block.title, "initial_ticks": block.initial_ticks}
-            if block.is_sequence:
+            if block.is_sequence():
                 return {
                     "type": "Sequence",
                     "title": block.title,
-                    "sequence": [serialize_block(phase) for phase in block.sequence],
+                    "sequence": [serialize_block(phase) for phase in block.phase_list],
                     "initial_repetitions": block.initial_repetitions
                 }
@@ -98,23 +99,33 @@
         return self.state == "running"
 
-    def is_paused(self):
+    def paused(self):
         return self.state == "paused"
 
     def abort(self):
         self.current_block.abort()
-        self.state = "finished"
+        self.state = "aborted"
 
-    def finished(self):
-        if (self.current_block.finished()) and (self.current_block.is_final()):
-            self.state = "finished"
+    def current_block_is_final(self):
+        index = self.blocks.index(self.current_block)
+        return index == (len(self.blocks) - 1)
+
+    def completed(self):
+        if (self.current_block.completed()) and (self.current_block_is_final()):
+            self.state = "completed"
             return True
         else:
             return False
 
+    def aborted(self):
+        return self.state == "aborted"
+
+    def terminated(self):
+        return (self.aborted() or self.completed())
+
     def advance_to_next_block(self):
         """Helper method to move to the next block in the schedule."""
-        if self.current_block_index < len(self.blocks) - 1:
-            self.current_block_index += 1
-            self.current_block = self.blocks[self.current_block_index]
+        current_block_index = self.blocks.index(self.current_block)
+        if current_block_index < len(self.blocks) - 1:
+            self.current_block = self.blocks[current_block_index+1]
 
     def skip(self):
@@ -126,5 +137,5 @@
             print("Skip the next phase in sequence")
             self.current_block.skip()
-            if self.current_block.finished():
+            if self.current_block.completed():
                 self.current_block = self.upcoming_blocks()[0]
             return
@@ -143,14 +154,10 @@
         return []
 
-    def current_block_is_final(self):
-        index = self.blocks.index(self.current_block)
-        return index == (len(self.blocks) - 1)
-
     def tick(self, ticks):
-        if not self.finished():
+        if not self.completed():
             self.current_block.tick(ticks)
-            if self.current_block.finished():
+            if self.current_block.completed():
                 if self.current_block_is_final():
-                    self.abort()
+                    self.state = "completed"
                 else:
                     self.skip()
Index: flowtimer/main.py
===================================================================
--- flowtimer/main.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ flowtimer/main.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -117,5 +117,5 @@
     def tick(self):
 
-        if self.schedule.is_paused():
+        if self.schedule.paused():
             return
         self.label_start.pack_forget()
@@ -161,9 +161,7 @@
     def skip(self):
         self.schedule.skip()
-        if self.schedule.finished():
-            print("finished")
 
     def toggle_tick(self):
-        if self.schedule.is_paused():
+        if self.schedule.paused():
             self.freeze_button.config(relief="raised", fg='black')
             self.label_sequence.config(fg="white")
Index: tests/test_phase.py
===================================================================
--- tests/test_phase.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ tests/test_phase.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -32,6 +32,6 @@
         phase = Phase("Warm-up", 300)
         phase.abort()
-        assert phase.state == "finished"
-        assert phase.finished() is True
+        assert phase.state == "aborted"
+        assert phase.aborted() is True
 
     def test_phase_tick(self):
@@ -47,5 +47,5 @@
         phase.tick(300)
         assert phase.ticks_left == 0
-        assert phase.finished() is True
+        assert phase.completed() is True
 
     def test_phase_tick_beyond_completion(self):
Index: tests/test_recurring_phase_sequence.py
===================================================================
--- tests/test_recurring_phase_sequence.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ tests/test_recurring_phase_sequence.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -10,7 +10,5 @@
     @pytest.fixture
     def recurring_phase_sequence(self):
-        phase_list = [Phase("Huddle", 10), Phase("Tasking", 5),
-                      Phase("Work", 45), Phase("Break", 15)]
-        return RecurringPhaseSequence(phase_list, 3)
+        return RecurringPhaseSequence.default()
 
     def test_from_json(self):
@@ -19,6 +17,6 @@
         assert isinstance(sequence, RecurringPhaseSequence)
         assert sequence.initial_repetitions == 3
-        assert len(sequence.phase_list) == 4
-        assert sequence.phase_list[0].title == "Huddle"
+        assert len(sequence.phase_list) == 3
+        assert sequence.phase_list[0].title == "Tasking"
 
     def test_to_json(self, recurring_phase_sequence):
@@ -28,9 +26,9 @@
         assert data['initial_repetitions'] == 3
         assert data['passes_left'] == 3
-        assert len(data['phase_list']) == 4
+        assert len(data['phase_list']) == 3
 
     def test_initial_state(self, recurring_phase_sequence):
         assert recurring_phase_sequence.state == "initial"
-        assert recurring_phase_sequence.current_phase.title == "Huddle"
+        assert recurring_phase_sequence.current_phase.title == "Tasking"
         assert recurring_phase_sequence.passes_left == 3
 
@@ -41,12 +39,12 @@
 
     def test_phases_left_in_pass(self, recurring_phase_sequence):
-        assert recurring_phase_sequence.phases_left_in_pass() == 3
+        assert recurring_phase_sequence.phases_left_in_pass() == 2
         recurring_phase_sequence.tick(10)
-        assert recurring_phase_sequence.phases_left_in_pass() == 2
+        assert recurring_phase_sequence.phases_left_in_pass() == 1
 
     def test_upcoming_phases_in_pass(self, recurring_phase_sequence):
         upcoming = recurring_phase_sequence.upcoming_phases_in_pass()
-        assert len(upcoming) == 3
-        assert upcoming[0].title == "Tasking"
+        assert len(upcoming) == 2
+        assert upcoming[0].title == "Work"
 
     def test_ticks_left(self, recurring_phase_sequence):
@@ -58,22 +56,18 @@
         assert recurring_phase_sequence.ticks_left == (total_ticks - 10)
 
-    def test_finished(self, recurring_phase_sequence):
-        assert not recurring_phase_sequence.finished()
+    def test_completed(self, recurring_phase_sequence):
+        assert not recurring_phase_sequence.completed()
         for _ in range(3):
             for phase in recurring_phase_sequence.phase_list:
                 recurring_phase_sequence.tick(phase.initial_ticks)
-        assert recurring_phase_sequence.finished()
+        assert recurring_phase_sequence.completed()
 
     def test_abort(self, recurring_phase_sequence):
         recurring_phase_sequence.abort()
-        assert recurring_phase_sequence.state == "finished"
-        assert recurring_phase_sequence.current_phase.finished()
+        assert recurring_phase_sequence.state == "aborted"
+        assert recurring_phase_sequence.current_phase.aborted()
 
     def test_tick_progression(self, recurring_phase_sequence):
-        recurring_phase_sequence.tick(10)
-        assert recurring_phase_sequence.current_phase.title == "Tasking"
-        assert recurring_phase_sequence.passes_left == 3
-
-        recurring_phase_sequence.tick(5)
+        recurring_phase_sequence.tick(6)
         assert recurring_phase_sequence.current_phase.title == "Work"
         assert recurring_phase_sequence.passes_left == 3
@@ -84,10 +78,10 @@
 
         recurring_phase_sequence.tick(15)
-        assert recurring_phase_sequence.current_phase.title == "Huddle"
+        assert recurring_phase_sequence.current_phase.title == "Tasking"
         assert recurring_phase_sequence.passes_left == 2
 
     def test_unrolled(self, recurring_phase_sequence):
         unrolled_phases = recurring_phase_sequence.unrolled()
-        assert len(unrolled_phases) == 12
-        assert unrolled_phases[0].title == "Huddle"
+        assert len(unrolled_phases) == 9
+        assert unrolled_phases[0].title == "Tasking"
         assert unrolled_phases[-1].title == "Break"
Index: tests/test_schedule.py
===================================================================
--- tests/test_schedule.py	(revision 5f4ef8e306c784daf790d281b05b7f74f52cbdcd)
+++ tests/test_schedule.py	(revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b)
@@ -1,110 +1,112 @@
 import pytest
+import json
 from flowtimer.Schedule import Schedule
 from flowtimer.Phase import Phase
+from flowtimer.RecurringPhaseSequence import RecurringPhaseSequence
+
 
 class TestSchedule:
-    
-    def test_schedule_initialization(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        assert schedule.phase_list == [phase1, phase2]
-        assert schedule.current_phase == phase1
+
+    @pytest.fixture
+    def setup_schedule(self):
+        #  Set up some real Phase and RecurringPhaseSequence objects for testing
+        phase1 = Phase("Phase 1", 300)
+        phase2 = Phase("Phase 2", 600)
+        sequence = RecurringPhaseSequence("Sequence 1", [phase1, phase2], 2)
+        blocks = [phase1, sequence]
+        schedule = Schedule("Test Schedule", blocks)
+        return schedule, phase1, phase2, sequence
+
+    def test_initialization(self, setup_schedule):
+        schedule, phase1, _, _ = setup_schedule
+        assert schedule.title == "Test Schedule"
+        assert schedule.blocks == [phase1, schedule.blocks[1]]
+        assert schedule.current_block == phase1
         assert schedule.state == "initial"
 
-    def test_schedule_start(self):
-        phase1 = Phase("Warm-up", 300)
-        schedule = Schedule([phase1])
+    def test_default_json_string(self):
+        default_json = Schedule.default_json_string()
+        assert isinstance(default_json, str)
+
+    def test_from_json(self):
+        json_string = Schedule.default_json_string()
+        schedule = Schedule.from_json(json_string)
+        assert schedule.title == "Default"
+        assert len(schedule.blocks) == 2
+        assert isinstance(schedule.blocks[0], Phase)
+        assert isinstance(schedule.blocks[1], RecurringPhaseSequence)
+
+    def test_to_json(self, setup_schedule):
+        schedule, _, _, _ = setup_schedule
+        json_string = schedule.to_json()
+        assert isinstance(json_string, str)
+        data = json.loads(json_string)
+        assert data['title'] == "Test Schedule"
+        assert len(data['blocks']) == 2
+
+    def test_start(self, setup_schedule):
+        schedule, phase1, _, _ = setup_schedule
         schedule.start()
-    
         assert schedule.state == "running"
-        assert schedule.current_phase.running() is True
-    
-    def test_schedule_pause(self):
-        phase1 = Phase("Warm-up", 300)
-        schedule = Schedule([phase1])
+        # assert phase1.ticks_left < phase1.initial_ticks  # Assuming the phase reduces ticks when started
+
+    def test_running(self, setup_schedule):
+        schedule, _, _, _ = setup_schedule
         schedule.start()
+        assert schedule.running() is True
         schedule.pause()
-    
-        assert schedule.state == "paused"
-        assert schedule.is_paused() is True
+        assert schedule.running() is False
 
-    def test_schedule_abort(self):
-        phase1 = Phase("Warm-up", 300)
-        schedule = Schedule([phase1])
-        schedule.start()
+    def test_paused(self, setup_schedule):
+        schedule, _, _, _ = setup_schedule
+        schedule.pause()
+        assert schedule.paused() is True
+
+    def test_abort(self, setup_schedule):
+        schedule, _, _, _ = setup_schedule
         schedule.abort()
-    
-        assert schedule.state == "finished"
-        assert schedule.current_phase.finished() is True
+        assert schedule.state == "aborted"
 
-    def test_schedule_finished(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        assert schedule.finished() is False
-    
-        phase1.start()
-        phase1.tick(300)
-        assert phase1.finished() is True
-        assert schedule.finished() is False
-    
+    def test_completed(self, setup_schedule):
+        schedule, phase1, _, sequence = setup_schedule
+        schedule.tick(phase1.initial_ticks)  # Complete phase1
+        schedule.tick(sequence.initial_ticks)  # Complete sequence
+        schedule.tick(phase1.initial_ticks)  # Complete phase1
+        schedule.tick(sequence.initial_ticks)  # Complete sequence
+        print(schedule.current_block)
+        assert schedule.completed() is True
+        assert schedule.state == "completed"
+
+    def test_advance_to_next_block(self, setup_schedule):
+        schedule, _, _, sequence = setup_schedule
+        schedule.advance_to_next_block()
+        assert schedule.current_block == schedule.blocks[1]
+
+    def test_skip(self, setup_schedule):
+        schedule, _, _, sequence = setup_schedule
         schedule.skip()
-        schedule.current_phase.tick(600)
-        assert schedule.finished() is True
+        assert schedule.current_block == schedule.blocks[1]  # Should skip to Phase 2 within the sequence
 
-    def test_schedule_skip(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        schedule.start()
-        schedule.skip()
-    
-        assert schedule.current_phase == phase2
+    def test_total_ticks_left(self, setup_schedule):
+        schedule, phase1, phase2, sequence = setup_schedule
+        expected_total_ticks = phase1.ticks_left + sequence.ticks_left
+        assert schedule.total_ticks_left() == expected_total_ticks
 
-    def test_schedule_skip_at_final_phase(self):
-        phase1 = Phase("Warm-up", 300)
-        schedule = Schedule([phase1])
-    
-        schedule.start()
-        schedule.skip()
-    
-        assert schedule.state == "finished"
+    def test_upcoming_blocks(self, setup_schedule):
+        schedule, _, _, sequence = setup_schedule
+        assert schedule.upcoming_blocks() == [sequence]
 
-    def test_schedule_tick(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        schedule.start()
-        schedule.tick(300)
-    
-        assert phase1.finished() is True
-        assert schedule.current_phase == phase2
-        assert schedule.state == "running"
+    def test_current_block_is_final(self, setup_schedule):
+        schedule, _, _, sequence = setup_schedule
+        assert schedule.current_block_is_final() is False
+        schedule.advance_to_next_block()
+        assert schedule.current_block_is_final() is True
 
-    def test_schedule_tick_to_completion(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        schedule.start()
-        schedule.tick(300)  # Should finish phase1 and move to phase2
-        schedule.tick(600)  # Should finish phase2 and complete the schedule
-    
-        assert phase2.finished() is True
-        assert schedule.finished() is True
+    def test_tick(self, setup_schedule):
+        schedule, phase1, _, _ = setup_schedule
+        initial_ticks = phase1.ticks_left
+        schedule.tick(100)
+        assert phase1.ticks_left == initial_ticks - 100
 
-    def test_schedule_current_phase_is_final(self):
-        phase1 = Phase("Warm-up", 300)
-        phase2 = Phase("Workout", 600)
-        schedule = Schedule([phase1, phase2])
-    
-        assert schedule.current_phase_is_final() is False
-    
-        schedule.skip()
-        assert schedule.current_phase_is_final() is True
-
+        schedule.tick(phase1.ticks_left)  # Finish phase1
+        assert schedule.current_block == schedule.blocks[1]  # Should advance to the next block