chore: added tests and removed restart phase

this version also has recursive goals functional

test/pages/monitoringPage/MonitoringPage.test.tsx

@@ -51,6 +51,7 @@ describe('MonitoringPage', () => {
   const mockGetPhaseNames = jest.fn();
   const mockGetNorms = jest.fn();
   const mockGetGoals = jest.fn();
+  const mockGetGoalsWithDepth = jest.fn();
   const mockGetTriggers = jest.fn();
   const mockSetProgramState = jest.fn();
 
@@ -65,6 +66,7 @@ describe('MonitoringPage', () => {
         getNormsInPhase: mockGetNorms,
         getGoalsInPhase: mockGetGoals,
         getTriggersInPhase: mockGetTriggers,
+        getGoalsWithDepth: mockGetGoalsWithDepth,
         setProgramState: mockSetProgramState,
       };
       return selector(state);
@@ -81,7 +83,11 @@ describe('MonitoringPage', () => {
     // Default mock return values
     mockGetPhaseIds.mockReturnValue(['phase-1', 'phase-2']);
     mockGetPhaseNames.mockReturnValue(['Intro', 'Main']);
-    mockGetGoals.mockReturnValue([{ id: 'g1', name: 'Goal 1' }, { id: 'g2', name: 'Goal 2' }]);
+    mockGetGoals.mockReturnValue([{ id: 'g1', name: 'Goal 1'}, { id: 'g2', name: 'Goal 2'}]);
+    mockGetGoalsWithDepth.mockReturnValue([
+        { id: 'g1', name: 'Goal 1', level: 0 }, 
+        { id: 'g2', name: 'Goal 2', level: 0 }
+    ]);
     mockGetTriggers.mockReturnValue([{ id: 't1', name: 'Trigger 1' }]);
     mockGetNorms.mockReturnValue([
         { id: 'n1', norm: 'Norm 1', condition: null }, 

test/pages/monitoringPage/MonitoringPageAPI.test.ts

@@ -1,8 +1,7 @@
 import { renderHook, act, cleanup } from '@testing-library/react';
 import { 
     sendAPICall, 
-    nextPhase, 
-    resetPhase, 
+    nextPhase,  
     pauseExperiment, 
     playExperiment, 
     useExperimentLogger, 
@@ -116,14 +115,6 @@ describe('MonitoringPageAPI', () => {
       );
     });
 
-    test('resetPhase sends correct params', async () => {
-      await resetPhase();
-      expect(globalThis.fetch).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({ body: JSON.stringify({ type: 'reset_phase', context: '' }) })
-      );
-    });
-
     test('pauseExperiment sends correct params', async () => {
       await pauseExperiment();
       expect(globalThis.fetch).toHaveBeenCalledWith(

test/utils/programStore.test.ts

@@ -115,6 +115,89 @@ describe('useProgramStore', () => {
   });
 });
 
+describe('getGoalsWithDepth', () => {
+    const complexProgram: ReducedProgram = {
+      phases: [
+        {
+          id: 'phase-nested',
+          goals: [
+            // Level 0: Root Goal 1
+            {
+              id: 'root-1',
+              name: 'Root Goal 1',
+              plan: {
+                steps: [
+                  // This is an ACTION (no plan), should be ignored
+                  { id: 'action-1', type: 'speech' },
+                  
+                  // Level 1: Child Goal
+                  {
+                    id: 'child-1',
+                    name: 'Child Goal',
+                    plan: {
+                      steps: [
+                        // Level 2: Grandchild Goal
+                        { 
+                          id: 'grandchild-1', 
+                          name: 'Grandchild', 
+                          plan: { steps: [] } // Empty plan is still a plan
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            },
+            // Level 0: Root Goal 2 (Sibling)
+            {
+              id: 'root-2',
+              name: 'Root Goal 2',
+              plan: { steps: [] }
+            }
+          ]
+        }
+      ]
+    };
+
+    it('should flatten nested goals and assign correct depth levels', () => {
+      useProgramStore.getState().setProgramState(complexProgram);
+
+      const goals = useProgramStore.getState().getGoalsWithDepth('phase-nested');
+
+      // logic: Root 1 -> Child 1 -> Grandchild 1 -> Root 2
+      expect(goals).toHaveLength(4);
+
+      // Check Root 1
+      expect(goals[0]).toEqual(expect.objectContaining({ id: 'root-1', level: 0 }));
+      
+      // Check Child 1
+      expect(goals[1]).toEqual(expect.objectContaining({ id: 'child-1', level: 1 }));
+
+      // Check Grandchild 1
+      expect(goals[2]).toEqual(expect.objectContaining({ id: 'grandchild-1', level: 2 }));
+
+      // Check Root 2
+      expect(goals[3]).toEqual(expect.objectContaining({ id: 'root-2', level: 0 }));
+    });
+
+    it('should ignore steps that are not goals (missing "plan" property)', () => {
+      useProgramStore.getState().setProgramState(complexProgram);
+      const goals = useProgramStore.getState().getGoalsWithDepth('phase-nested');
+
+      // The 'action-1' object should NOT be in the list
+      const action = goals.find(g => g.id === 'action-1');
+      expect(action).toBeUndefined();
+    });
+
+    it('throws if phase does not exist', () => {
+      useProgramStore.getState().setProgramState(complexProgram);
+
+      expect(() =>
+        useProgramStore.getState().getGoalsWithDepth('missing-phase')
+      ).toThrow('phase with id:"missing-phase" not found');
+    });
+  });
+
 it('should return the names of all phases in the program', () => {
     // Define a program specifically with names for this test
     const programWithNames: ReducedProgram = {