diff --git a/.cursor/rules/specify-rules.mdc b/.cursor/rules/specify-rules.mdc
index 252349d..6a036fe 100644
--- a/.cursor/rules/specify-rules.mdc
+++ b/.cursor/rules/specify-rules.mdc
@@ -19,6 +19,7 @@ Auto-generated from all feature plans. Last updated: 2025-11-04
 - N/A (text serialization/deserialization library) (014-gram-serialization)
 - Haskell (GHC 9.x) + `megaparsec` (parsing), `hspec` (testing) (016-gram-parsing-conformance)
 - N/A (In-memory data structures) (016-gram-parsing-conformance)
+- Haskell (GHC 9.8/9.10) + `megaparsec` (parsing), `containers` (Map/Set), `text` (likely for efficiency, though current code uses String) (020-subject-serialization)
 
 - (001-pattern-data-structure)
 
@@ -38,9 +39,9 @@ tests/
 : Follow standard conventions
 
 ## Recent Changes
+- 020-subject-serialization: Added Haskell (GHC 9.8/9.10) + `megaparsec` (parsing), `containers` (Map/Set), `text` (likely for efficiency, though current code uses String)
 - 019-integration-polish: Added [if applicable, e.g., PostgreSQL, CoreData, files or N/A]
 - 018-pattern-path-semantics: Added [if applicable, e.g., PostgreSQL, CoreData, files or N/A]
-- 016-gram-parsing-conformance: Added Haskell (GHC 9.x) + `megaparsec` (parsing), `hspec` (testing)
 
 
 <!-- MANUAL ADDITIONS START -->
diff --git a/TODO.md b/TODO.md
index 551018b..5bd1b0f 100644
--- a/TODO.md
+++ b/TODO.md
@@ -35,29 +35,17 @@ Serialization and parsing for `Pattern Subject`.
 - **Parsing Conformance**: Verified 100% pass rate against `tree-sitter-gram` corpus (Feature 16).
 - **Validation**: `Gram.Validate` module implemented with duplicate definition, undefined reference, and arity checking.
 
----
-
-## 🗺️ Roadmap
+### Subject Identity & Serialization (Feature 20)
+Completed robust identity handling and round-trip capabilities.
 
-### 1. Subject Identity & Serialization (Feature 20)
-**Priority**: High / Next Up
-**Goal**: Serialize Subject instances to gram notation and parse gram notation to Subject instances, handling the identity requirement (Subject requires identity, but gram allows anonymous subjects).
-
-#### 10.1 Serialization Design
-- [ ] Design serialization format for Subject to gram notation
-- [ ] Handle anonymous subjects: gram syntax allows anonymous (unidentified) subjects, but Subject data type requires identity
-- [ ] Design strategy for assigning identity to anonymous subjects during serialization
-  - [ ] Option: Generate unique identifiers (e.g., UUIDs, sequential IDs)
-  - [ ] Option: Use placeholder identifiers that can be omitted in output
-  - [ ] Option: Track identity mapping for round-trip serialization
-- [ ] Implement `toGram :: Subject -> String` (serialize Subject to gram notation)
-- [ ] Implement `fromGram :: String -> Either ParseError Subject` (parse gram notation to Subject)
-- [ ] Write tests: verify serialization of subjects with all components
-- [ ] Write tests: verify parsing of gram notation with anonymous subjects
-- [ ] Write tests: verify round-trip serialization (parse . serialize = id, with identity handling)
+- **Identity Preservation**: Implemented sequential ID generation for anonymous subjects to ensure round-trip stability.
+- **Implicit Root**: Distinguishes between empty nodes `()` and implicit root containers `{}`.
+- **Round-Trip Verification**: Validated structural equality after serialization/deserialization cycles against the full test corpus.
 
 ---
 
+## 🗺️ Roadmap
+
 ### 2. Graph Views (Feature 21)
 **Priority**: High
 **Goal**: Interpret `Pattern` structures as different graph elements (nodes, relationships, walks) through categorical functors.
diff --git a/libs/gram/gram.cabal b/libs/gram/gram.cabal
index f621d1a..e86ab13 100644
--- a/libs/gram/gram.cabal
+++ b/libs/gram/gram.cabal
@@ -61,6 +61,7 @@ test-suite gram-test
         text >=2.0,
         megaparsec ^>=9.6,
         hspec ^>=2.11,
+        QuickCheck ^>=2.14,
         directory ^>=1.3,
         filepath ^>=1.4
 
diff --git a/libs/gram/src/Gram/Parse.hs b/libs/gram/src/Gram/Parse.hs
index 5de6cf9..6ffa8e0 100644
--- a/libs/gram/src/Gram/Parse.hs
+++ b/libs/gram/src/Gram/Parse.hs
@@ -459,6 +459,8 @@ parseGram = do
     else optional (try parseAnnotatedPattern) >>= \p -> return $ maybe [] (:[]) p
     
   additionalPatterns <- many (try (do
+    optionalSpaceWithNewlines
+    void $ optional (char ',')
     optionalSpaceWithNewlines
     nextChar <- lookAhead (satisfy (const True))
     if nextChar == '(' || nextChar == '[' || nextChar == '@'
diff --git a/libs/gram/src/Gram/Serialize.hs b/libs/gram/src/Gram/Serialize.hs
index 929ff02..7ad22bb 100644
--- a/libs/gram/src/Gram/Serialize.hs
+++ b/libs/gram/src/Gram/Serialize.hs
@@ -53,8 +53,8 @@ import Data.Char (isAlpha, isAlphaNum)
 
 -- | Escape special characters in strings for gram notation.
 --
--- Escapes quotes and backslashes in string values to ensure proper
--- serialization in gram notation.
+-- Escapes quotes, backslashes, and control characters in string values 
+-- to ensure proper serialization in gram notation.
 --
 -- === Examples
 --
@@ -63,11 +63,17 @@ import Data.Char (isAlpha, isAlphaNum)
 --
 -- >>> escapeString "He said \"Hello\""
 -- "He said \\\"Hello\\\""
+--
+-- >>> escapeString "Line 1\nLine 2"
+-- "Line 1\\nLine 2"
 escapeString :: String -> String
 escapeString = concatMap escapeChar
   where
     escapeChar '"' = "\\\""
     escapeChar '\\' = "\\\\"
+    escapeChar '\n' = "\\n"
+    escapeChar '\r' = "\\r"
+    escapeChar '\t' = "\\t"
     escapeChar c = [c]
 
 -- | Format a Symbol for gram notation.
@@ -177,7 +183,7 @@ serializeLabels lbls
   | Set.null lbls = ""
   | otherwise = ":" ++ intercalate ":" (Set.toList lbls)
 
--- | Serialize a Subject to gram notation (legacy function, kept for compatibility).
+    -- | Serialize a Subject to gram notation (legacy function, kept for compatibility).
 -- Note: This always uses node syntax. Use toGram for proper syntax selection.
 serializeSubject :: Subject -> String
 serializeSubject (Subject ident lbls props) =
@@ -186,6 +192,14 @@ serializeSubject (Subject ident lbls props) =
   serializeLabels lbls ++
   serializePropertyRecord props
 
+-- | Serialize pattern elements for implicit root (no brackets/pipe).
+-- Used when serializing the top-level Gram container.
+-- NOTE: This function is now inlined into toGram to handle properties.
+-- Keeping signature for potential reuse or removing if unused.
+-- serializeImplicitElements :: [Pattern Subject] -> String
+-- serializeImplicitElements elems = 
+--   intercalate "\n" (map toGram elems)
+
 -- | Serialize pattern elements to gram notation.
 --
 -- Converts a list of Pattern Subject elements to gram notation.
@@ -257,14 +271,33 @@ serializePatternElements elems
 -- "[g | a, b]"
 toGram :: Pattern Subject -> String
 toGram p@(Pattern subj elems)
+  | isImplicitRoot subj = serializeImplicitElements (properties subj) elems -- Implicit root -> record + elements
   | null elems = serializeSubjectAsNode subj  -- No elements -> node syntax
-  | otherwise = 
-      case isWalkPattern p of
-        Just edges -> serializeWalkPattern edges
-        Nothing -> case isEdgePattern p of
-          Just (rel, left, right) -> serializeEdgePattern rel left right
-          Nothing -> serializeSubjectAsSubject subj elems  -- Has elements -> subject syntax
+  | Just edges <- isWalkPattern p = serializeWalkPattern edges
+  | Just (rel, left, right) <- isEdgePattern p = serializeEdgePattern rel left right
+  | otherwise = serializeSubjectAsSubject subj elems  -- Has elements -> subject syntax
   where
+    -- | Check if subject is the Implicit Root
+    -- Identified by "Gram.Root" label.
+    isImplicitRoot :: Subject -> Bool
+    isImplicitRoot (Subject (Symbol "") lbls _) = "Gram.Root" `Set.member` lbls
+    isImplicitRoot _ = False
+
+    -- | Serialize pattern elements for implicit root (record + elements).
+    -- Note: We do NOT serialize the "Gram.Root" label itself, as it is implicit in the file structure.
+    serializeImplicitElements :: Map String Value -> [Pattern Subject] -> String
+    serializeImplicitElements props elems = 
+      let propsStr = if Map.null props then "" else serializePropertyRecord props
+          elemsStr = intercalate "\n" (map toGram elems)
+      in case (null propsStr, null elemsStr) of
+           (True, True) -> "{}" -- Empty graph/root
+           (False, True) -> trimLeadingSpace propsStr -- Remove leading space from serializePropertyRecord
+           (True, False) -> elemsStr
+           (False, False) -> trimLeadingSpace propsStr ++ "\n" ++ elemsStr
+
+    trimLeadingSpace (' ':xs) = xs
+    trimLeadingSpace xs = xs
+
     -- | Check if pattern is a Walk Pattern: [Gram.Walk | edge1, edge2, ...]
     isWalkPattern :: Pattern Subject -> Maybe [Pattern Subject]
     isWalkPattern (Pattern (Subject _ lbls _) edges)
diff --git a/libs/gram/src/Gram/Transform.hs b/libs/gram/src/Gram/Transform.hs
index c07832c..9cefc73 100644
--- a/libs/gram/src/Gram/Transform.hs
+++ b/libs/gram/src/Gram/Transform.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE FlexibleContexts #-}
 module Gram.Transform
   ( transformGram
   ) where
@@ -10,109 +11,158 @@ import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Set (Set)
 import qualified Data.Set as Set
+import Control.Monad.State (State, evalState, get, put)
+import Data.Char (isDigit)
+
+type Transform = State Int
 
 -- | Transform a CST Gram into a Core Pattern Subject
 transformGram :: CST.Gram -> P.Pattern S.Subject
-transformGram (CST.Gram record patterns) =
+transformGram gram = evalState (transformGram' gram) (findMaxId gram + 1)
+
+-- | Find the maximum numeric suffix of IDs matching "#<N>" in the CST
+findMaxId :: CST.Gram -> Int
+findMaxId (CST.Gram _ patterns) = maximum (0 : concatMap scanPattern patterns)
+  where
+    scanPattern (CST.AnnotatedPattern _ elements) = concatMap scanElement elements
+
+    scanElement (CST.PEPath path) = scanPath path
+    scanElement (CST.PESubjectPattern sp) = scanSubjectPattern sp
+    scanElement (CST.PEReference ident) = scanIdentifier (Just ident)
+
+    scanPath (CST.Path startNode segments) = 
+      scanNode startNode ++ concatMap scanSegment segments
+
+    scanSegment (CST.PathSegment rel nextNode) = 
+      scanRelationship rel ++ scanNode nextNode
+
+    scanNode (CST.Node subjData) = scanSubjectData subjData
+
+    scanRelationship (CST.Relationship _ subjData) = scanSubjectData subjData
+
+    scanSubjectPattern (CST.SubjectPattern subjData nested) = 
+      scanSubjectData subjData ++ concatMap scanElement nested
+
+    scanSubjectData Nothing = []
+    scanSubjectData (Just (CST.SubjectData ident _ _)) = scanIdentifier ident
+
+    scanIdentifier (Just (CST.IdentSymbol (CST.Symbol s))) = case parseGeneratedId s of
+      Just n -> [n]
+      Nothing -> []
+    scanIdentifier _ = []
+
+    parseGeneratedId ('#':rest) | all isDigit rest && not (null rest) = Just (read rest)
+    parseGeneratedId _ = Nothing
+
+transformGram' :: CST.Gram -> Transform (P.Pattern S.Subject)
+transformGram' (CST.Gram record patterns) =
   case (record, patterns) of
     (Just props, []) -> 
       -- Only record
-      P.Pattern (S.Subject (S.Symbol "") Set.empty props) []
-    (Just props, pats) ->
-      -- Record + Patterns: Record becomes root properties, patterns become elements
-      P.Pattern (S.Subject (S.Symbol "") Set.empty props) (map transformPattern pats)
+      return $ P.Pattern (S.Subject (S.Symbol "") (Set.singleton "Gram.Root") props) []
+    (Just props, pats) -> do
+      pats' <- mapM transformPattern pats
+      -- Explicit root record.
+      return $ P.Pattern (S.Subject (S.Symbol "") (Set.singleton "Gram.Root") props) pats'
     (Nothing, [p]) ->
-      -- Single pattern (common case)
       transformPattern p
-    (Nothing, pats) ->
-      -- Multiple patterns without root record: wrap in implicit root
-      P.Pattern (S.Subject (S.Symbol "") Set.empty Map.empty) (map transformPattern pats)
+    (Nothing, pats) -> do
+      pats' <- mapM transformPattern pats
+      return $ P.Pattern (S.Subject (S.Symbol "") (Set.singleton "Gram.Root") Map.empty) pats'
 
-transformPattern :: CST.AnnotatedPattern -> P.Pattern S.Subject
+transformPattern :: CST.AnnotatedPattern -> Transform (P.Pattern S.Subject)
 transformPattern (CST.AnnotatedPattern _ elements) =
   case elements of
     [el] -> transformElement el
-    (first:rest) -> 
-      -- Multiple elements: First acts as container/root of the sequence (legacy behavior preserved)
-      -- OR we should wrap them? The existing parser treated comma-separated lists by nesting:
-      -- "a, b" -> Pattern a [Pattern b]
-      -- Let's preserve this for now to pass tests.
-      let root = transformElement first
-          others = map transformElement rest
-      in P.Pattern (P.value root) (P.elements root ++ others)
-    [] -> P.Pattern (S.Subject (S.Symbol "") Set.empty Map.empty) []
-
-transformElement :: CST.PatternElement -> P.Pattern S.Subject
+    (first:rest) -> do
+      root <- transformElement first
+      others <- mapM transformElement rest
+      return $ P.Pattern (P.value root) (P.elements root ++ others)
+    [] -> return $ P.Pattern (S.Subject (S.Symbol "") Set.empty Map.empty) []
+
+transformElement :: CST.PatternElement -> Transform (P.Pattern S.Subject)
 transformElement (CST.PEPath path) = transformPath path
 transformElement (CST.PESubjectPattern b) = transformSubjectPattern b
-transformElement (CST.PEReference ident) =
-  P.Pattern (S.Subject (transformIdentifier (Just ident)) Set.empty Map.empty) []
+transformElement (CST.PEReference ident) = do
+  sym <- transformIdentifier (Just ident)
+  return $ P.Pattern (S.Subject sym Set.empty Map.empty) []
 
 -- | Transform a path into a Pattern.
 -- 
 -- 1. Single Node: (a) -> Pattern a []
 -- 2. Single Edge: (a)-[r]->(b) -> Pattern r [a, b]
 -- 3. Walk: (a)-[r1]->(b)-[r2]->(c) -> Pattern walk [Pattern r1 [a, b], Pattern r2 [b, c]]
-transformPath :: CST.Path -> P.Pattern S.Subject
+transformPath :: CST.Path -> Transform (P.Pattern S.Subject)
 transformPath (CST.Path startNode segments) =
   case segments of
     [] -> transformNode startNode
-    [seg] -> 
+    [seg] -> do
       -- Single Edge case: Return the edge pattern directly
       -- (a)-[r]->(b) becomes [r | a, b]
-      let left = transformNode startNode
-          right = transformNode (CST.segmentNode seg)
-          rel = transformRelationship (CST.segmentRel seg)
-      in P.Pattern (P.value rel) [left, right]
-    _ -> 
+      left <- transformNode startNode
+      right <- transformNode (CST.segmentNode seg)
+      rel <- transformRelationship (CST.segmentRel seg)
+      return $ P.Pattern (P.value rel) [left, right]
+    _ -> do
       -- Walk case (multiple segments): Return a Walk Pattern containing edges
       -- (a)-[r1]->(b)-[r2]->(c) becomes [walk | [r1 | a, b], [r2 | b, c]]
-      let edges = constructWalkEdges startNode segments
-          -- Use a specific label for Walk container to distinguish it
-          walkSubject = S.Subject (S.Symbol "") (Set.singleton "Gram.Walk") Map.empty
-      in P.Pattern walkSubject edges
+      leftP <- transformNode startNode
+      edges <- constructWalkEdges leftP segments
+      -- Use a specific label for Walk container to distinguish it
+      let walkSubject = S.Subject (S.Symbol "") (Set.singleton "Gram.Walk") Map.empty
+      return $ P.Pattern walkSubject edges
 
 -- | Construct a list of Edge Patterns from a start node and path segments.
-constructWalkEdges :: CST.Node -> [CST.PathSegment] -> [P.Pattern S.Subject]
-constructWalkEdges _ [] = []
-constructWalkEdges leftNode (seg:rest) =
+-- We pass the transformed left pattern to ensure identity continuity in the walk.
+constructWalkEdges :: P.Pattern S.Subject -> [CST.PathSegment] -> Transform [P.Pattern S.Subject]
+constructWalkEdges _ [] = return []
+constructWalkEdges leftP (seg:rest) = do
   let rightNode = CST.segmentNode seg
-      leftP = transformNode leftNode
-      rightP = transformNode rightNode
-      relP = transformRelationship (CST.segmentRel seg)
-      -- Create self-contained edge: [rel | left, right]
-      edge = P.Pattern (P.value relP) [leftP, rightP]
-  in edge : constructWalkEdges rightNode rest
-
-transformNode :: CST.Node -> P.Pattern S.Subject
-transformNode (CST.Node subjData) =
-  let subj = maybe emptySubject transformSubjectData subjData
-  in P.Pattern subj []
-
-transformSubjectPattern :: CST.SubjectPattern -> P.Pattern S.Subject
-transformSubjectPattern (CST.SubjectPattern subjData nested) =
-  let subj = maybe emptySubject transformSubjectData subjData
-      nestedPats = map transformElement nested
-  in P.Pattern subj nestedPats
-
-transformRelationship :: CST.Relationship -> P.Pattern S.Subject
-transformRelationship (CST.Relationship _ subjData) =
+  rightP <- transformNode rightNode
+  relP <- transformRelationship (CST.segmentRel seg)
+  -- Create self-contained edge: [rel | left, right]
+  let edge = P.Pattern (P.value relP) [leftP, rightP]
+  restEdges <- constructWalkEdges rightP rest
+  return (edge : restEdges)
+
+transformNode :: CST.Node -> Transform (P.Pattern S.Subject)
+transformNode (CST.Node subjData) = do
+  subj <- maybe transformEmptySubject transformSubjectData subjData
+  return $ P.Pattern subj []
+
+transformSubjectPattern :: CST.SubjectPattern -> Transform (P.Pattern S.Subject)
+transformSubjectPattern (CST.SubjectPattern subjData nested) = do
+  subj <- maybe transformEmptySubject transformSubjectData subjData
+  nestedPats <- mapM transformElement nested
+  return $ P.Pattern subj nestedPats
+
+transformRelationship :: CST.Relationship -> Transform (P.Pattern S.Subject)
+transformRelationship (CST.Relationship _ subjData) = do
   -- Arrow string is currently ignored in Pattern Subject (as per design)
-  let subj = maybe emptySubject transformSubjectData subjData
-  in P.Pattern subj []
+  subj <- maybe transformEmptySubject transformSubjectData subjData
+  return $ P.Pattern subj []
 
-transformSubjectData :: CST.SubjectData -> S.Subject
-transformSubjectData (CST.SubjectData ident labels props) =
-  S.Subject
-    (transformIdentifier ident)
+transformSubjectData :: CST.SubjectData -> Transform S.Subject
+transformSubjectData (CST.SubjectData ident labels props) = do
+  sym <- transformIdentifier ident
+  return $ S.Subject
+    sym
     labels
     props
 
-transformIdentifier :: Maybe CST.Identifier -> S.Symbol
-transformIdentifier Nothing = S.Symbol ""
-transformIdentifier (Just (CST.IdentSymbol (CST.Symbol s))) = S.Symbol s
-transformIdentifier (Just (CST.IdentString s)) = S.Symbol s
-transformIdentifier (Just (CST.IdentInteger i)) = S.Symbol (show i)
+transformIdentifier :: Maybe CST.Identifier -> Transform S.Symbol
+transformIdentifier Nothing = generateId
+transformIdentifier (Just (CST.IdentSymbol (CST.Symbol s))) = return $ S.Symbol s
+transformIdentifier (Just (CST.IdentString s)) = return $ S.Symbol s
+transformIdentifier (Just (CST.IdentInteger i)) = return $ S.Symbol (show i)
+
+transformEmptySubject :: Transform S.Subject
+transformEmptySubject = do
+  sym <- generateId
+  return $ S.Subject sym Set.empty Map.empty
 
-emptySubject :: S.Subject
-emptySubject = S.Subject (S.Symbol "") Set.empty Map.empty
+generateId :: Transform S.Symbol
+generateId = do
+  i <- get
+  put (i + 1)
+  return $ S.Symbol ("#" ++ show i)
diff --git a/libs/gram/tests/Spec/Gram/ParseSpec.hs b/libs/gram/tests/Spec/Gram/ParseSpec.hs
index 588e87a..0f53bd7 100644
--- a/libs/gram/tests/Spec/Gram/ParseSpec.hs
+++ b/libs/gram/tests/Spec/Gram/ParseSpec.hs
@@ -22,15 +22,21 @@ spec = do
         it "parses empty node" $ do
           case fromGram "()" of
             Right p -> do
-              -- Empty node should have empty subject
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
+              -- Empty node should have generated ID
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              labels (value p) `shouldBe` Set.empty
+              properties (value p) `shouldBe` empty
               elements p `shouldBe` []
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses node with empty record" $ do
           case fromGram "({})" of
             Right p -> do
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              labels (value p) `shouldBe` Set.empty
+              properties (value p) `shouldBe` empty
               elements p `shouldBe` []
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
@@ -38,7 +44,10 @@ spec = do
           case fromGram "({ k : \"v\" })" of
             Right p -> do
               let props = fromList [("k", VString "v")]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              labels (value p) `shouldBe` Set.empty
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses identified node with record" $ do
@@ -59,7 +68,10 @@ spec = do
         it "parses empty subject" $ do
           case fromGram "[ ]" of
             Right p -> do
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              labels (value p) `shouldBe` Set.empty
+              properties (value p) `shouldBe` empty
               elements p `shouldBe` []
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
@@ -97,16 +109,23 @@ spec = do
         it "parses single node pattern" $ do
           case fromGram "()" of
             Right p -> do
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              labels (value p) `shouldBe` Set.empty
+              properties (value p) `shouldBe` empty
               elements p `shouldBe` []
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses two node members" $ do
-          case fromGram "(),()" of
+          case fromGram "() ()" of
             Right p -> do
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
-              length (elements p) `shouldBe` 1
-              value (head (elements p)) `shouldBe` Subject (Symbol "") Set.empty empty
+              value p `shouldBe` Subject (Symbol "") (Set.singleton "Gram.Root") empty
+              length (elements p) `shouldBe` 2
+              let [e1, e2] = elements p
+              let Symbol id1 = identity (value e1)
+              let Symbol id2 = identity (value e2)
+              take 1 id1 `shouldBe` "#"
+              take 1 id2 `shouldBe` "#"
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses one relationship" $ do
@@ -158,35 +177,45 @@ spec = do
           case fromGram "({ n : 1 })" of
             Right p -> do
               let props = fromList [("n", VInteger 1)]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses string property" $ do
           case fromGram "({ s : \"a\" })" of
             Right p -> do
               let props = fromList [("s", VString "a")]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses range property (closed range)" $ do
           case fromGram "({ i : 1..10 })" of
             Right p -> do
               let props = fromList [("i", VRange (RangeValue (Just 1) (Just 10)))]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses range property (lower bound only)" $ do
           case fromGram "({ i : 1... })" of
             Right p -> do
               let props = fromList [("i", VRange (RangeValue (Just 1) Nothing))]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses range property (upper bound only)" $ do
           case fromGram "({ i : ...100 })" of
             Right p -> do
               let props = fromList [("i", VRange (RangeValue Nothing (Just 100)))]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              let Symbol id = identity (value p)
+              take 1 id `shouldBe` "#"
+              properties (value p) `shouldBe` props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses map property" $ do
@@ -209,7 +238,7 @@ spec = do
         it "parses empty record" $ do
           case fromGram "{}" of
             Right p -> do
-              value p `shouldBe` Subject (Symbol "") Set.empty empty
+              value p `shouldBe` Subject (Symbol "") (Set.singleton "Gram.Root") empty
               elements p `shouldBe` []
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
@@ -217,14 +246,14 @@ spec = do
           case fromGram "{ n : 1 }" of
             Right p -> do
               let props = fromList [("n", VInteger 1)]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              value p `shouldBe` Subject (Symbol "") (Set.singleton "Gram.Root") props
             Left err -> expectationFailure $ "Parse failed: " ++ show err
         
         it "parses record followed by node" $ do
           case fromGram "{ s : \"a\" }\n()" of
             Right p -> do
               let props = fromList [("s", VString "a")]
-              value p `shouldBe` Subject (Symbol "") Set.empty props
+              value p `shouldBe` Subject (Symbol "") (Set.singleton "Gram.Root") props
               length (elements p) `shouldBe` 1
             Left err -> expectationFailure $ "Parse failed: " ++ show err
       
@@ -239,3 +268,79 @@ spec = do
           case fromGram "(g (a:Person))" of
             Right _ -> expectationFailure "Should have failed - nodes cannot nest"
             Left (ParseError _) -> return ()  -- Expected to fail
+
+      describe "User Story 2: Anonymous Subject Handling" $ do
+        
+        it "assigns unique IDs to anonymous nodes" $ do
+          -- Two anonymous nodes separated by space (parsed as 2 top-level patterns)
+          case fromGram "() ()" of
+            Right p -> do
+              let elems = elements p
+              length elems `shouldBe` 2
+              let [n1, n2] = elems
+              -- Check generated IDs
+              let Symbol id1 = identity (value n1)
+              let Symbol id2 = identity (value n2)
+              
+              -- IDs should be non-empty and distinct
+              id1 `shouldNotBe` ""
+              id2 `shouldNotBe` ""
+              id1 `shouldNotBe` id2
+              
+              -- IDs should follow format #<N>
+              take 1 id1 `shouldBe` "#"
+              take 1 id2 `shouldBe` "#"
+            Left err -> expectationFailure $ "Parse failed: " ++ show err
+            
+        it "assigns unique IDs to anonymous path elements" $ do
+          -- Path with anonymous nodes and relationship: ()-[]->()
+          case fromGram "()-[]->()" of
+            Right p -> do
+              -- Pattern is relationship: [rel | left, right]
+              let relSubject = value p
+              let [left, right] = elements p
+              
+              let Symbol relId = identity relSubject
+              let Symbol leftId = identity (value left)
+              let Symbol rightId = identity (value right)
+              
+              -- All IDs should be distinct and generated
+              relId `shouldNotBe` ""
+              leftId `shouldNotBe` ""
+              rightId `shouldNotBe` ""
+              
+              leftId `shouldNotBe` rightId
+              relId `shouldNotBe` leftId
+              relId `shouldNotBe` rightId
+              
+              take 1 relId `shouldBe` "#"
+            Left err -> expectationFailure $ "Parse failed: " ++ show err
+
+        it "avoids collision with existing generated-style IDs" $ do
+          -- Input has explicit #1. Generator should skip it and use #2 (or higher).
+          case fromGram "(`#1`) ()" of
+            Right p -> do
+              let elems = elements p
+              length elems `shouldBe` 2
+              let [e1, e2] = elems
+              let Symbol id1 = identity (value e1)
+              let Symbol id2 = identity (value e2)
+              
+              id1 `shouldBe` "#1"
+              id2 `shouldNotBe` "#1"
+              take 1 id2 `shouldBe` "#"
+            Left err -> expectationFailure $ "Parse failed: " ++ show err
+
+        it "re-round-trips generated IDs safely (US3 Collision Prevention)" $ do
+          -- () -> #1 -> (#1)
+          -- (#1), () -> #1, #2 -> (#1), (#2)
+          case fromGram "(`#1`) ()" of
+            Right p -> do
+              let elems = elements p
+              let [e1, e2] = elems
+              let Symbol id1 = identity (value e1)
+              let Symbol id2 = identity (value e2)
+              
+              -- Ensure they are distinct
+              id1 `shouldNotBe` id2
+            Left err -> expectationFailure $ "Parse failed: " ++ show err
diff --git a/libs/gram/tests/Spec/Gram/SerializeSpec.hs b/libs/gram/tests/Spec/Gram/SerializeSpec.hs
index b7872d0..ea78f42 100644
--- a/libs/gram/tests/Spec/Gram/SerializeSpec.hs
+++ b/libs/gram/tests/Spec/Gram/SerializeSpec.hs
@@ -2,13 +2,19 @@
 module Spec.Gram.SerializeSpec where
 
 import Test.Hspec
+import Test.Hspec.QuickCheck
+import qualified Test.QuickCheck as QC
+import Test.QuickCheck (forAll, listOf, listOf1, Gen)
 import Gram.Serialize (toGram)
+import Gram.Parse (fromGram)
 import Pattern.Core (Pattern(..))
 import Subject.Core (Subject(..), Symbol(..))
 import Subject.Value (Value(..), RangeValue(..))
 import Data.Map (empty, fromList)
+import qualified Data.Map as Map
 import Data.Set (Set)
 import qualified Data.Set as Set
+import Data.Text (pack)
 
 spec :: Spec
 spec = do
@@ -38,9 +44,11 @@ spec = do
           toGram p `shouldBe` "(:Person)"
         
         it "serializes anonymous subject (empty Symbol) without label" $ do
-          let s = Subject (Symbol "") Set.empty empty
+          -- Subject "" is reserved for Implicit Root, which must have Gram.Root label
+          let s = Subject (Symbol "") (Set.singleton "Gram.Root") empty
           let p = Pattern { value = s, elements = [] }
-          toGram p `shouldBe` "()"
+          -- Empty props/elems -> "{}" (Empty Graph Record)
+          toGram p `shouldBe` "{}"
       
       describe "subject with standard value types" $ do
         it "serializes subject with integer property" $ do
@@ -279,3 +287,81 @@ spec = do
           result `shouldContain` "temp:-10"
           result `shouldContain` "ratio:-0.5"
           result `shouldContain` "})"
+
+      describe "User Story 1: Round-trip Serialization" $ do
+        
+        it "handles complex special character escaping" $ do
+          let specialStr = "Line 1\nLine 2\tTabbed\rCarriage \"Quote\" \\Backslash"
+          let props = fromList [("data", VString specialStr)]
+          let s = Subject (Symbol "n") Set.empty props
+          let p = Pattern { value = s, elements = [] }
+          let serialized = toGram p
+          
+          -- Verify serialization format
+          serialized `shouldContain` "\\n"
+          serialized `shouldContain` "\\t"
+          serialized `shouldContain` "\\r"
+          serialized `shouldContain` "\\\""
+          serialized `shouldContain` "\\\\"
+          
+          -- Verify round-trip
+          let parsed = fromGram serialized
+          parsed `shouldBe` Right p
+
+      describe "User Story 3: Identity Preservation" $ do
+        
+        it "preserves explicit alphanumeric IDs" $ do
+          let idStr = "user123"
+          let s = Subject (Symbol idStr) Set.empty empty
+          let p = Pattern { value = s, elements = [] }
+          let serialized = toGram p
+          serialized `shouldBe` "(user123)"
+          
+          let parsed = fromGram serialized
+          parsed `shouldBe` Right p
+          
+        it "preserves explicit IDs requiring quoting" $ do
+          -- IDs with spaces require backtick quoting
+          let idStr = "user name"
+          let s = Subject (Symbol idStr) Set.empty empty
+          let p = Pattern { value = s, elements = [] }
+          let serialized = toGram p
+          serialized `shouldBe` "(`user name`)"
+          
+          let parsed = fromGram serialized
+          parsed `shouldBe` Right p
+          
+        it "preserves special characters in IDs" $ do
+          -- IDs with backticks need escaping
+          let idStr = "user`name"
+          let s = Subject (Symbol idStr) Set.empty empty
+          let p = Pattern { value = s, elements = [] }
+          let serialized = toGram p
+          serialized `shouldBe` "(`user\\`name`)"
+          
+          let parsed = fromGram serialized
+          parsed `shouldBe` Right p
+
+        prop "serializes and parses back to an equivalent pattern (Round Trip)" $ 
+          forAll genPattern $ \p -> do
+            let serialized = toGram p
+            let parsed = fromGram serialized
+            parsed `shouldBe` Right p
+
+-- Generators for Property Tests
+genPattern :: Gen (Pattern Subject)
+genPattern = do
+  val <- genSubject
+  -- Limit recursion depth for simple round-trip test
+  return $ Pattern val []
+
+genSubject :: Gen Subject
+genSubject = do
+  idStr <- listOf1 (QC.elements ['a'..'z'])
+  lbls <- listOf (listOf1 (QC.elements ['A'..'Z']))
+  -- Generate simple string properties to verify property serialization
+  k <- listOf1 (QC.elements ['a'..'z'])
+  v <- listOf1 (QC.elements ['a'..'z'])
+  let props = Map.fromList [(k, VString v)]
+  return $ Subject (Symbol idStr) (Set.fromList lbls) props
+
diff --git a/specs/020-subject-serialization/checklists/requirements.md b/specs/020-subject-serialization/checklists/requirements.md
new file mode 100644
index 0000000..6c9da78
--- /dev/null
+++ b/specs/020-subject-serialization/checklists/requirements.md
@@ -0,0 +1,34 @@
+# Specification Quality Checklist: Subject Identity and Serialization
+
+**Purpose**: Validate specification completeness and quality before proceeding to planning
+**Created**: 2025-11-29
+**Feature**: [spec.md](../spec.md)
+
+## Content Quality
+
+- [x] No implementation details (languages, frameworks, APIs)
+- [x] Focused on user value and business needs
+- [x] Written for non-technical stakeholders
+- [x] All mandatory sections completed
+
+## Requirement Completeness
+
+- [x] No [NEEDS CLARIFICATION] markers remain
+- [x] Requirements are testable and unambiguous
+- [x] Success criteria are measurable
+- [x] Success criteria are technology-agnostic (no implementation details)
+- [x] All acceptance scenarios are defined
+- [x] Edge cases are identified
+- [x] Scope is clearly bounded
+- [x] Dependencies and assumptions identified
+
+## Feature Readiness
+
+- [x] All functional requirements have clear acceptance criteria
+- [x] User scenarios cover primary flows
+- [x] Feature meets measurable outcomes defined in Success Criteria
+- [x] No implementation details leak into specification
+
+## Notes
+
+- The specification includes function signatures (e.g., `toGram`) in requirements. Since this is a low-level library, the API surface is the primary product interface, so this is considered acceptable and necessary for clear requirements, even if technically an "implementation detail" in a broader context.
diff --git a/specs/020-subject-serialization/contracts/api.md b/specs/020-subject-serialization/contracts/api.md
new file mode 100644
index 0000000..9f2921d
--- /dev/null
+++ b/specs/020-subject-serialization/contracts/api.md
@@ -0,0 +1,23 @@
+# API Contract: Subject Serialization
+
+## Module: `Gram.Serialize`
+
+```haskell
+-- | Serialize a Pattern Subject to gram notation string.
+-- Handles escaping, quoting, and structure.
+toGram :: Pattern Subject -> String
+```
+
+## Module: `Gram.Parse`
+
+```haskell
+-- | Parse a gram notation string into a Pattern Subject.
+-- Automatically assigns unique IDs (e.g., #1) to anonymous subjects.
+fromGram :: String -> Either ParseError (Pattern Subject)
+```
+
+## Invariants
+
+1.  **Round-Trip**: `fromGram (toGram s) == Right s` (modulo potential ID generation for previously anonymous subjects, which become named).
+2.  **Identity**: `toGram` output for a Subject with ID `#1` is `(#1)` (or similar valid syntax).
+
diff --git a/specs/020-subject-serialization/data-model.md b/specs/020-subject-serialization/data-model.md
new file mode 100644
index 0000000..f68c8bc
--- /dev/null
+++ b/specs/020-subject-serialization/data-model.md
@@ -0,0 +1,34 @@
+# Data Model: Subject Identity and Serialization
+
+## Entities
+
+### Subject
+
+The core data structure representing a node or relationship's content.
+
+| Field | Type | Description | Constraints |
+|-------|------|-------------|-------------|
+| `identity` | `Symbol` | Unique identifier | **Mandatory**. Cannot be empty string in a valid graph (though type allows it). Parsed anonymous subjects receive generated IDs (e.g., `#1`). |
+| `labels` | `Set String` | Classification tags | Unique set. |
+| `properties` | `Map String Value` | Key-value attributes | Keys are strings. Values are typed. |
+
+### Identity Generation
+
+- **Format**: `#<N>` (e.g., `#1`, `#2`, ...)
+- **Scope**: Local to a single `fromGram` parse operation.
+- **Counter**: Starts at 1 for each parse.
+
+## Type Definitions
+
+```haskell
+-- | Core Subject type
+data Subject = Subject
+  { identity :: Symbol
+  , labels :: Set String
+  , properties :: Map String Value
+  }
+
+-- | Symbol wrapper
+newtype Symbol = Symbol String
+```
+
diff --git a/specs/020-subject-serialization/plan.md b/specs/020-subject-serialization/plan.md
new file mode 100644
index 0000000..9495e57
--- /dev/null
+++ b/specs/020-subject-serialization/plan.md
@@ -0,0 +1,84 @@
+# Implementation Plan: Subject Identity and Serialization
+
+**Branch**: `020-subject-serialization` | **Date**: 2025-11-29 | **Spec**: [spec.md](spec.md)
+**Input**: Feature specification from `/specs/020-subject-serialization/spec.md`
+
+**Note**: This template is filled in by the `/speckit.plan` command. See `.specify/templates/commands/plan.md` for the execution workflow.
+
+## Summary
+
+Implement robust round-trip serialization for `Subject` instances to/from gram notation. Key requirements include:
+1.  `toGram`: Serialize `Subject` to valid gram string, handling escaping and structure.
+2.  `fromGram`: Parse gram string to `Subject`, ensuring all subjects (including anonymous ones) receive a unique identity (FR-003).
+3.  Ensure round-trip consistency (`fromGram . toGram == id`).
+
+## Technical Context
+
+**Language/Version**: Haskell (GHC 9.8/9.10)
+**Primary Dependencies**: `megaparsec` (parsing), `containers` (Map/Set), `text` (likely for efficiency, though current code uses String)
+**Storage**: N/A (In-memory data structures)
+**Testing**: `hspec` for unit/property testing
+**Target Platform**: Cross-platform (Library)
+**Project Type**: Library (`libs/gram`, `libs/subject`)
+**Performance Goals**: Efficient parsing/serialization for moderate graph sizes.
+**Constraints**: Must maintain purity of `fromGram` (or use a pure State monad) to fit existing functional patterns.
+**Scale/Scope**: Core library functionality.
+
+## Constitution Check
+
+*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
+
+**Mandatory Compliance Checks:**
+
+- **Code Quality (NON-NEGOTIABLE)**: The design extends existing well-structured modules (`Gram.Parse`, `Gram.Serialize`, `Gram.Transform`).
+- **Testing Standards (NON-NEGOTIABLE)**: Will include round-trip property tests and unit tests for anonymous ID generation.
+- **Conceptual Consistency**: Adheres to `Subject` as the canonical data structure for graph attributes.
+- **Mathematical Clarity**: ID generation strategy (sequential) ensures deterministic behavior, preserving referential transparency of the parse function.
+- **Multi-Language Reference Alignment**: The generated ID strategy should be simple enough to implement in other languages (e.g., counter-based).
+
+**Violations must be documented in Complexity Tracking section below.**
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/020-subject-serialization/
+├── plan.md              # This file
+├── research.md          # Phase 0 output
+├── data-model.md        # Phase 1 output
+├── quickstart.md        # Phase 1 output
+├── contracts/           # Phase 1 output
+└── tasks.md             # Phase 2 output
+```
+
+### Source Code (repository root)
+
+```text
+libs/
+├── gram/
+│   ├── src/
+│   │   └── Gram/
+│   │       ├── Parse.hs       # Update to return CST
+│   │       ├── Serialize.hs   # Update/Verify serialization
+│   │       └── Transform.hs   # Update to handle ID generation
+│   └── tests/
+│       └── Spec/
+│           └── Gram/
+│               ├── ParseSpec.hs     # Add anonymous ID tests
+│               └── SerializeSpec.hs # Add round-trip tests
+└── subject/
+    └── src/
+        └── Subject/
+            └── Core.hs        # Reference for Subject type
+```
+
+**Structure Decision**: Enhance existing `gram` library modules. No new projects/libraries needed.
+
+## Complexity Tracking
+
+> **Fill ONLY if Constitution Check has violations that must be justified**
+
+| Violation | Why Needed | Simpler Alternative Rejected Because |
+|-----------|------------|-------------------------------------|
+| None | | |
diff --git a/specs/020-subject-serialization/quickstart.md b/specs/020-subject-serialization/quickstart.md
new file mode 100644
index 0000000..b81b843
--- /dev/null
+++ b/specs/020-subject-serialization/quickstart.md
@@ -0,0 +1,42 @@
+# Quickstart: Subject Serialization
+
+## Basic Usage
+
+```haskell
+import Gram.Serialize (toGram)
+import Gram.Parse (fromGram)
+import Pattern.Core (Pattern(..))
+import Subject.Core (Subject(..), Symbol(..))
+import Data.Set (fromList)
+import Data.Map (empty)
+
+-- 1. Create a Subject
+let subj = Subject (Symbol "n") (fromList ["Person"]) empty
+let pat = Pattern subj []
+
+-- 2. Serialize
+let gram = toGram pat
+-- Result: "(n:Person)"
+
+-- 3. Parse
+let parsed = fromGram "(n:Person)"
+-- Result: Right (Pattern (Subject (Symbol "n") ...))
+```
+
+## Handling Anonymous Subjects
+
+When parsing anonymous subjects, unique IDs are automatically assigned using `#<N>` format:
+
+```haskell
+-- Parse anonymous node
+let result = fromGram "()"
+-- Result: Right (Pattern (Subject (Symbol "#1") ...))
+
+-- Parse anonymous path
+let result2 = fromGram "()-[:KNOWS]->()"
+-- Result: Pattern with:
+--   Left Node: Subject "#1"
+--   Right Node: Subject "#2"
+--   Relationship: Subject "#3" (if implicit) or named if specified
+```
+
diff --git a/specs/020-subject-serialization/research.md b/specs/020-subject-serialization/research.md
new file mode 100644
index 0000000..eb63a6c
--- /dev/null
+++ b/specs/020-subject-serialization/research.md
@@ -0,0 +1,52 @@
+# Research: Subject Identity and Serialization
+
+**Feature**: Subject Identity and Serialization (`020-subject-serialization`)
+**Status**: Complete
+
+## 1. Identity Generation for Anonymous Subjects
+
+**Context**: Gram syntax allows anonymous subjects (e.g., `()`, `()-[]->()`), but the `Subject` data type requires a mandatory `identity` field (Symbol). We need a strategy to assign unique IDs to these subjects during parsing.
+
+**Options Considered**:
+1.  **UUIDs**: Generate a random UUID for each anonymous subject.
+    *   *Pros*: Globally unique.
+    *   *Cons*: Requires `IO` or a random seed, making `fromGram` impure or complex. Harder to test (non-deterministic).
+2.  **Sequential IDs (Global)**: Use a global counter.
+    *   *Pros*: Simple.
+    *   *Cons*: Requires `IO` / `MVar` / global state. Breaks purity.
+3.  **Sequential IDs (Local/Deterministic)**: Use a counter scoped to the `fromGram` call (e.g., `#1`, `#2`).
+    *   *Pros*: Pure, deterministic, easy to test.
+    *   *Cons*: IDs are only unique within that specific parse result. Merging two parsed graphs could cause collisions if not handled (but that's a separate concern; `Subject` semigroup handles merging).
+
+**Decision**: **Option 3: Sequential IDs (Local/Deterministic)**.
+We will generate IDs of the form `#<N>` (or similar distinct prefix) using a `State` monad during the transformation phase (`Gram.Transform`).
+
+**Implementation Details**:
+- Modify `transformGram` to be `transformGram :: CST.Gram -> P.Pattern S.Subject` (keeping signature pure) but internally use `evalState` with a stateful transformation function.
+- State will track the next available ID index.
+- `transformIdentifier` will look like:
+  ```haskell
+  transformIdentifier :: Maybe CST.Identifier -> State Int S.Symbol
+  transformIdentifier Nothing = do
+    n <- get
+    put (n + 1)
+    return $ S.Symbol ("#" ++ show n)
+  transformIdentifier (Just (CST.IdentSymbol (CST.Symbol s))) = return $ S.Symbol s
+  -- ...
+  ```
+
+## 2. Round-trip Consistency
+
+**Context**: We want `fromGram . toGram == id` (conceptually).
+If we parse `()` -> `Subject "#1"`, then `toGram` will produce `(#1)`.
+Parsing `(#1)` -> `Subject "#1"`.
+This preserves the data identity.
+
+**Decision**: Accept that anonymous subjects become named subjects after a round-trip. This is consistent with the requirement that `Subject` *has* an identity. The "anonymous" syntax is just a shorthand for "I don't care about the ID, make one up". Once made up, it persists.
+
+## 3. Special Character Escaping
+
+**Context**: `Gram.Serialize` already handles some escaping. We need to ensure it covers all cases (quotes, backslashes) to ensure valid gram output.
+
+**Decision**: Review and enhance `escapeString` in `Gram.Serialize` if necessary. Current implementation looks basic but likely sufficient for standard string types. Will add tests to confirm.
+
diff --git a/specs/020-subject-serialization/spec.md b/specs/020-subject-serialization/spec.md
new file mode 100644
index 0000000..f03e079
--- /dev/null
+++ b/specs/020-subject-serialization/spec.md
@@ -0,0 +1,93 @@
+# Feature Specification: Subject Identity and Serialization
+
+**Feature Branch**: `020-subject-serialization`
+**Created**: 2025-11-29
+**Status**: Draft
+**Input**: User description: "Begin \"subject identity and serialization\" as described in @TODO.md"
+
+## User Scenarios & Testing *(mandatory)*
+
+<!--
+  IMPORTANT: User stories should be PRIORITIZED as user journeys ordered by importance.
+  Each user story/journey must be INDEPENDENTLY TESTABLE - meaning if you implement just ONE of them,
+  you should still have a viable MVP (Minimum Viable Product) that delivers value.
+-->
+
+### User Story 1 - Round-trip Serialization (Priority: P1)
+
+As a developer using the library, I need to serialize `Subject` instances to gram notation and parse them back so that I can persist and retrieve graph data without loss of information.
+
+**Why this priority**: This is the core functionality. Without reliable round-trip serialization, the library cannot effectively communicate with external systems or storage.
+
+**Independent Test**: Can be tested by generating random `Subject` instances, serializing them to text, parsing the text back, and asserting equality.
+
+**Acceptance Scenarios**:
+
+1. **Given** a `Subject` with a specific identifier, labels, and properties, **When** I serialize it to gram notation, **Then** the output string matches the expected gram syntax.
+2. **Given** a serialized gram string of a specific subject, **When** I parse it, **Then** I get back a `Subject` object identical to the original.
+3. **Given** a `Subject` with nested relationships, **When** I serialize and then parse it, **Then** the structure and all values are preserved.
+
+---
+
+### User Story 2 - Handling Anonymous Subjects (Priority: P2)
+
+As a user writing gram patterns, I want to define patterns with anonymous nodes (e.g., `()-[:KNOWS]->()`) and have them parsed into valid `Subject` objects so that I don't have to manually assign IDs when they are not needed for my query.
+
+**Why this priority**: Gram syntax supports and encourages anonymous nodes for pattern matching. The library must handle this common case to be compliant with the language.
+
+**Independent Test**: Can be tested by providing gram strings with anonymous nodes and verifying that the parsed `Subject` objects have valid, non-conflicting identifiers assigned.
+
+**Acceptance Scenarios**:
+
+1. **Given** a gram string with an anonymous node `()`, **When** I parse it, **Then** the resulting `Subject` has a generated unique identifier.
+2. **Given** a gram string with multiple anonymous nodes `()-[]->()`, **When** I parse it, **Then** each resulting `Subject` has a distinct unique identifier.
+
+---
+
+### User Story 3 - Identity Preservation (Priority: P3)
+
+As a system integrator, I want to ensure that when I serialize a `Subject` with a specific ID, that same ID is present in the output text, so that external systems can recognize the entity.
+
+**Why this priority**: Crucial for interoperability, though slightly less fundamental than the basic mechanics of serialization.
+
+**Independent Test**: Verify that specific ID strings appear in the serialized output.
+
+**Acceptance Scenarios**:
+
+1. **Given** a `Subject` with ID "user-123", **When** I serialize it, **Then** the string "user-123" appears in the identifier position of the gram output.
+
+---
+
+### Edge Cases
+
+- What happens when a `Subject` contains characters that need escaping in gram notation (e.g., quotes in property values)?
+- How does the system handle parsing errors or invalid gram syntax?
+- What happens if a generated ID for an anonymous subject collides with an existing explicit ID (unlikely if using UUIDs, but possible)?
+- Handling of empty or minimal subjects.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: System MUST implement `toGram :: Subject -> String` to serialize a `Subject` and its structure to valid gram notation.
+- **FR-002**: System MUST implement `fromGram :: String -> Either ParseError Subject` to parse gram notation into a `Subject`.
+- **FR-003**: System MUST automatically assign unique identifiers to any anonymous subjects encountered during parsing, as the `Subject` type requires an identity.
+- **FR-004**: Serialization MUST properly escape special characters in string values to ensure valid gram syntax.
+- **FR-005**: Parsing MUST correctly handle all valid gram value types (strings, integers, decimals, booleans) within a Subject.
+- **FR-006**: The serialization/parsing cycle MUST satisfy the round-trip property: `fromGram(toGram(s)) == Right s` for any valid `Subject` s.
+- **FR-007**: The system MUST support a strategy for identity generation (e.g., sequential, random/UUID) that ensures local uniqueness within a parse operation.
+
+### Key Entities *(include if feature involves data)*
+
+- **Subject**: The core data structure representing a node/entity, containing an identifier (Id), a set of labels, and a map of properties.
+- **Gram Notation**: The string representation of the graph data.
+- **Identity (Id)**: A unique string or value identifying a Subject.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: 100% of valid `Subject` instances defined in the test suite can be successfully round-tripped (serialized then parsed) without error or data loss.
+- **SC-002**: Parsing of valid gram strings with anonymous subjects succeeds 100% of the time, producing `Subject` instances with non-empty identifiers.
+- **SC-003**: Serialization performance is sufficient to handle batch operations (e.g., < 10ms per simple subject on standard hardware - though strict benchmarking isn't the primary goal here, it shouldn't be noticeably slow).
+- **SC-004**: All tests for special character escaping pass.
diff --git a/specs/020-subject-serialization/tasks.md b/specs/020-subject-serialization/tasks.md
new file mode 100644
index 0000000..8138f88
--- /dev/null
+++ b/specs/020-subject-serialization/tasks.md
@@ -0,0 +1,245 @@
+---
+description: "Tasks for implementing subject identity and serialization in gram-hs"
+---
+
+# Tasks: Subject Identity and Serialization
+
+**Input**: Design documents from `/specs/020-subject-serialization/`
+**Prerequisites**: plan.md, spec.md, research.md, data-model.md, contracts/, quickstart.md
+
+**Tests**: Tests are INCLUDED as fundamental tasks given the rigorous nature of the project.
+
+**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: Can run in parallel (different files, no dependencies)
+- **[Story]**: Which user story this task belongs to (e.g., US1, US2, US3)
+- Include exact file paths in descriptions
+
+## Phase 1: Setup (Shared Infrastructure)
+
+**Purpose**: Project initialization and basic structure
+
+- [x] T001 Create `libs/gram/tests/Spec/Gram/SerializeSpec.hs` skeleton if needed
+- [x] T002 Create `libs/gram/tests/Spec/Gram/ParseSpec.hs` skeleton if needed (likely exists)
+
+---
+
+## Phase 2: Foundational (Blocking Prerequisites)
+
+**Purpose**: Core infrastructure that MUST be complete before ANY user story can be implemented
+
+**⚠️ CRITICAL**: No user story work can begin until this phase is complete
+
+- [x] T003 Verify `libs/gram/src/Gram/Transform.hs` state monad readiness (conceptually)
+
+**Checkpoint**: Foundation ready - user story implementation can now begin in parallel
+
+---
+
+## Phase 3: User Story 1 - Round-trip Serialization (Priority: P1) 🎯 MVP
+
+**Goal**: Implement robust serialization/parsing cycle for explicit subjects.
+
+**Independent Test**: Serialize `Subject` to string, parse back, assert equality.
+
+### Tests for User Story 1
+
+> **NOTE: Write these tests FIRST, ensure they FAIL before implementation**
+> **PERFORMANCE**: Always use timeouts (`timeout 60 cabal test`).
+
+- [x] T004 [US1] Add property test for round-trip serialization in `libs/gram/tests/Spec/Gram/SerializeSpec.hs`
+- [x] T005 [P] [US1] Add unit test for special character escaping in `libs/gram/tests/Spec/Gram/SerializeSpec.hs`
+
+### Implementation for User Story 1
+
+- [x] T006 [US1] Update `libs/gram/src/Gram/Serialize.hs` to handle all escaping cases (quotes, backslashes)
+- [x] T007 [US1] Ensure `libs/gram/src/Gram/Serialize.hs` produces valid gram syntax for all value types
+- [x] T008 [US1] Run tests with timeout: `timeout 60 cabal test` to verify round-trip
+- [x] T009 [US1] Git commit: "feat: implement round-trip serialization - US1"
+
+**Checkpoint**: At this point, User Story 1 should be fully functional and testable independently
+
+---
+
+## Phase 4: User Story 2 - Handling Anonymous Subjects (Priority: P2)
+
+**Goal**: Automatically assign unique identifiers (e.g., `#1`) to anonymous subjects during parsing.
+
+**Independent Test**: Parse gram string with multiple `()` and verify unique, sequential IDs.
+
+### Tests for User Story 2
+
+- [x] T010 [US2] Add unit test for anonymous node parsing in `libs/gram/tests/Spec/Gram/ParseSpec.hs`
+- [x] T011 [P] [US2] Add unit test for anonymous path parsing `()-[]->()` in `libs/gram/tests/Spec/Gram/ParseSpec.hs`
+
+### Implementation for User Story 2
+
+- [x] T012 [US2] Modify `libs/gram/src/Gram/Transform.hs` to use `State Int` monad for ID generation
+- [x] T013 [US2] Implement `transformIdentifier` with `#<N>` format logic in `libs/gram/src/Gram/Transform.hs`
+- [x] T014 [US2] Update `libs/gram/src/Gram/Parse.hs` `fromGram` to run the stateful transformation
+- [x] T015 [US2] Verify generated IDs follow `#<N>` format (illegal as unquoted identifier)
+- [x] T016 [US2] Run tests with timeout: `timeout 60 cabal test` to verify anonymous ID generation
+- [x] T017 [US2] Git commit: "feat: implement anonymous subject ID generation - US2"
+
+**Checkpoint**: At this point, User Stories 1 AND 2 should both work independently
+
+---
+
+## Phase 5: User Story 3 - Identity Preservation (Priority: P3)
+
+**Goal**: Ensure specific IDs are preserved exactly during round-trip.
+
+**Independent Test**: Serialize subject with ID "user-123", verify "user-123" in output.
+
+### Tests for User Story 3
+
+- [ ] T018 [US3] Add unit test for explicit ID preservation in `libs/gram/tests/Spec/Gram/SerializeSpec.hs`
+
+### Implementation for User Story 3
+
+- [ ] T019 [US3] Verify `libs/gram/src/Gram/Serialize.hs` correctly handles explicit IDs (should already be covered, but explicit check needed)
+- [ ] T020 [US3] Run tests with timeout: `timeout 60 cabal test` to verify all User Story 3 tests pass
+- [x] T021 [US3] Git commit: "feat: verify identity preservation - US3"
+
+**Checkpoint**: All user stories should now be independently functional
+
+---
+
+## Phase 6: Polish & Cross-Cutting Concerns
+
+**Purpose**: Improvements that affect multiple user stories
+
+- [x] T022 Run quickstart validation from `specs/020-subject-serialization/quickstart.md`
+- [x] T023 Run full test suite with timeout: `timeout 60 cabal test`
+- [x] T024 Git commit: "docs: finalize subject serialization feature"
+
+---
+
+## Dependencies & Execution Order
+
+### Phase Dependencies
+
+- **Setup (Phase 1)**: No dependencies - can start immediately
+- **Foundational (Phase 2)**: Depends on Setup completion - BLOCKS all user stories
+- **User Stories (Phase 3+)**: All depend on Foundational phase completion
+  - User stories can then proceed in parallel (if staffed)
+  - Or sequentially in priority order (P1 → P2 → P3)
+- **Polish (Final Phase)**: Depends on all desired user stories being complete
+
+### User Story Dependencies
+
+- **User Story 1 (P1)**: Can start after Foundational (Phase 2) - No dependencies on other stories
+- **User Story 2 (P2)**: Can start after Foundational (Phase 2) - Modifies Transform logic, but conceptually independent
+- **User Story 3 (P3)**: Can start after Foundational (Phase 2) - Independent check
+
+### Within Each User Story
+
+- Tests (if included) MUST be written and FAIL before implementation
+- Models before services
+- Services before endpoints
+- Core implementation before integration
+- Story complete before moving to next priority
+
+### Parallel Opportunities
+
+- All Setup tasks marked [P] can run in parallel
+- All Foundational tasks marked [P] can run in parallel (within Phase 2)
+- Once Foundational phase completes, all user stories can start in parallel (if team capacity allows)
+- All tests for a user story marked [P] can run in parallel
+- Models within a story marked [P] can run in parallel
+- Different user stories can be worked on in parallel by different team members
+
+---
+
+## Parallel Example: User Story 1
+
+```bash
+# Launch all tests for User Story 1 together (if tests requested):
+Task: "Add unit test for special character escaping in libs/gram/tests/Spec/Gram/SerializeSpec.hs"
+
+# Launch all models for User Story 1 together:
+Task: "Update libs/gram/src/Gram/Serialize.hs to handle all escaping cases"
+```
+
+---
+
+## Implementation Strategy
+
+### MVP First (User Story 1 Only)
+
+1. Complete Phase 1: Setup
+2. Complete Phase 2: Foundational (CRITICAL - blocks all stories)
+3. Complete Phase 3: User Story 1
+4. **STOP and VALIDATE**: Test User Story 1 independently
+5. Deploy/demo if ready
+
+### Incremental Delivery
+
+1. Complete Setup + Foundational → Foundation ready
+2. Add User Story 1 → Test independently → Deploy/Demo (MVP!)
+3. Add User Story 2 → Test independently → Deploy/Demo
+4. Add User Story 3 → Test independently → Deploy/Demo
+5. Each story adds value without breaking previous stories
+
+### Parallel Team Strategy
+
+With multiple developers:
+
+1. Team completes Setup + Foundational together
+2. Once Foundational is done:
+   - Developer A: User Story 1
+   - Developer B: User Story 2
+   - Developer C: User Story 3
+3. Stories complete and integrate independently
+
+---
+
+## Notes
+
+- [P] tasks = different files, no dependencies
+- [Story] label maps task to specific user story for traceability
+- Each user story should be independently completable and testable
+- Verify tests fail before implementing
+- **Git commit after each user story completion** (see tasks T009, T017, T021)
+- Stop at any checkpoint to validate story independently
+- Avoid: vague tasks, same file conflicts, cross-story dependencies that break independence
+
+## Testing Performance Guidelines
+
+### Test Execution Timeouts
+
+**CRITICAL**: Always use timeouts when running tests to prevent hanging:
+
+- **First test run after implementation**: Use `timeout 60` (60 seconds) to catch any infinite loops or performance issues
+- **Subsequent test runs**: Use `timeout 30` (30 seconds) for normal verification
+- **Full test suite**: Should complete in under 1 minute total
+
+### Test Performance Requirements
+
+- **Unit tests**: Each test should complete in <100ms
+- **Property-based tests**: Each property test should complete in <10ms (use bounded generators)
+- **Full test suite**: Should complete in <1 minute total
+- **Individual test phases**: Should complete in <10 seconds
+
+### Troubleshooting Slow Tests
+
+If tests hang or take too long:
+
+1. **Check for infinite recursion**: Verify recursive functions have proper base cases
+2. **Check for ambiguous function calls**: Use explicit module qualifiers (e.g., `Prelude.foldl` vs `foldl`)
+3. **Check test data size**: Ensure property-based tests use bounded generators
+4. **Check for lazy evaluation issues**: Ensure strict evaluation where needed
+5. **Verify test isolation**: Ensure tests don't depend on shared mutable state
+
+### Test Execution Commands
+
+```bash
+# First run after implementation (with timeout):
+timeout 60 cabal test
+
+# Normal verification (with timeout):
+timeout 30 cabal test
+```
+