diff --git a/src/parse.py b/src/parse.py
index e0ec360..b4e927e 100644
--- a/src/parse.py
+++ b/src/parse.py
@@ -91,8 +91,8 @@
 # The note skipper in a wrapper class for easy testing
 class NoteSkipper:
     # Skip a note
-    def skip_note(self, stream):
-        context = ParseContext(ParseTask.PARSE_NOTE, stream.peek(), None)
+    def skip_note(self, stream, parent_context):
+        context = ParseContext(ParseTask.PARSE_NOTE, stream.peek(), parent_context)
         read_token(stream, "StartNote", context)
         while True:
             s = read_token(stream, None, context)
@@ -111,7 +111,7 @@
         while token is not None:
             # Found a note, skip it
             if token.value == "StartNote":
-                self.skip_note(stream)
+                self.skip_note(stream, None)
             # EndNote found outside note
             elif token.value == "EndNote":
                 raise ParseErrorException(ParseError.FOUND_ENDNOTE, token, None, None)
diff --git a/tests/parse/test_clear_notes.py b/tests/parse/test_clear_notes.py
index 9df41f9..1b0b16c 100644
--- a/tests/parse/test_clear_notes.py
+++ b/tests/parse/test_clear_notes.py
@@ -15,14 +15,14 @@
 
 # Dummy parse_note implementation for testing note clearing
 # This redefines skip_note to skip the StartNote and not do anything else
-def clear_notes_skip_note_valid(stream):
+def clear_notes_skip_note_valid(stream, parent_context):
     stream.pop()
     return None
 
 
 # Dummy parse_note implementation for testing error propgation
 # This redefines skip_note to always throw an error
-def clear_notes_skip_note_error(stream):
+def clear_notes_skip_note_error(stream, parent_context):
     s = stream.peek()
     raise ParseErrorException(ParseError.TEST_ERROR, s, None, None)
 
diff --git a/tests/parse/test_note.py b/tests/parse/test_note.py
index 84f2142..641bafc 100644
--- a/tests/parse/test_note.py
+++ b/tests/parse/test_note.py
@@ -18,6 +18,7 @@
     ParseTask,
 )
 from src.syntax import SyntaxStream, SyntaxType
+from tests.parse.test_parse import draw_parse_context
 from tests.test_syntax import (
     draw_token_by_value,
     draw_syntax_random,
@@ -59,7 +60,7 @@
 def test_parse_note_valid(canary, test_data):
     tokens = test_data
     stream = SyntaxStream(tokens + [canary])
-    skipped = NoteSkipper().skip_note(stream)
+    skipped = NoteSkipper().skip_note(stream, None)
     assert skipped is None
     assert stream.pop() == canary
     assert stream.pop() is None
@@ -73,22 +74,23 @@
 @composite
 def draw_syntax_note_invalid_nostartnote(draw):
     tokens = draw(draw_syntax_note_valid())
+    parent_context = draw(draw_parse_context())
     if draw(booleans()):
         token = draw(draw_syntax_random())
         assume(not (token.type == SyntaxType.TOKEN and token.value == "StartNote"))
         new_tokens = [token] + tokens[1:0]
-        context = ParseContext(ParseTask.PARSE_NOTE, new_tokens[0], None)
+        context = ParseContext(ParseTask.PARSE_NOTE, new_tokens[0], parent_context)
         if token.type == SyntaxType.TOKEN:
             error = ParseErrorException(
                 ParseError.WRONG_TOKEN, token, "StartNote", context
             )
         else:
             error = ParseErrorException(ParseError.NOT_TOKEN, token, None, context)
-        return (new_tokens, error)
+        return (new_tokens, error, parent_context)
     else:
-        context = ParseContext(ParseTask.PARSE_NOTE, None, None)
+        context = ParseContext(ParseTask.PARSE_NOTE, None, parent_context)
         error = ParseErrorException(ParseError.NO_TOKEN, None, None, context)
-        return ([], error)
+        return ([], error, parent_context)
 
 
 # Generate note with a StartNote token in it
@@ -99,9 +101,10 @@
     tokens = draw(draw_syntax_note_valid())
     start = draw(draw_token_by_value("StartNote"))
     new_tokens = insert_random(draw, tokens, start)
-    context = ParseContext(ParseTask.PARSE_NOTE, new_tokens[0], None)
+    parent_context = draw(draw_parse_context())
+    context = ParseContext(ParseTask.PARSE_NOTE, new_tokens[0], parent_context)
     error = ParseErrorException(ParseError.FOUND_STARTNOTE, start, None, context)
-    return (new_tokens, error)
+    return (new_tokens, error, parent_context)
 
 
 # Generate note without EndNote
@@ -110,9 +113,10 @@
 @composite
 def draw_syntax_note_invalid_noendnote(draw):
     tokens = draw(draw_syntax_note_valid())
-    context = ParseContext(ParseTask.PARSE_NOTE, tokens[0], None)
+    parent_context = draw(draw_parse_context())
+    context = ParseContext(ParseTask.PARSE_NOTE, tokens[0], parent_context)
     error = ParseErrorException(ParseError.NO_TOKEN, None, None, context)
-    return (tokens[0:-1], error)
+    return (tokens[0:-1], error, parent_context)
 
 
 # Generate an invalid note case
@@ -129,10 +133,10 @@
 # Test that parse_note errors in invalid cases
 @given(draw_syntax_note_invalid())
 def test_parse_note_invalid(test_data):
-    (tokens, error) = test_data
+    (tokens, error, context) = test_data
     stream = SyntaxStream(tokens)
     try:
-        parsed = NoteSkipper().skip_note(stream)
+        parsed = NoteSkipper().skip_note(stream, context)
         raise AssertionError("Parsed invalid data: %s" % (parsed))
     except ParseErrorException as e:
         assert e == error