diff --git a/Editor/DialogLineRefDrawer.cs b/Editor/DialogLineRefDrawer.cs
index 692aa09..c2736e0 100644
--- a/Editor/DialogLineRefDrawer.cs
+++ b/Editor/DialogLineRefDrawer.cs
@@ -3,50 +3,39 @@ using UnityEditor;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>
-    /// Drawer for <see cref="DialogLineRef"/>. Shows the library + id picker on one row, the inline
-    /// fallback text area underneath, and a resolved preview below that. Preserves WYSIWYG — the
-    /// final text is always visible.
-    /// </summary>
+    /// <summary>Id dropdown (library inherited from the owning asset's <c>library</c> field) + inline fallback + resolved preview.</summary>
     [CustomPropertyDrawer(typeof(DialogLineRef))]
     public class DialogLineRefDrawer : PropertyDrawer {
         private const string NonePlaceholder = "<none>";
-        private const string EmptyLibraryPlaceholder = "<assign a library first>";
+        private const string EmptyLibraryPlaceholder = "<set library on the parent asset>";
         private const float PreviewHeight = 32f;
 
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) {
-            var libraryProp = property.FindPropertyRelative("library");
             var idProp = property.FindPropertyRelative("id");
             var inlineProp = property.FindPropertyRelative("inlineText");
+            var library = ResolveLibrary(property);
 
             EditorGUI.BeginProperty(position, label, property);
 
             var lineHeight = EditorGUIUtility.singleLineHeight;
             var spacing = EditorGUIUtility.standardVerticalSpacing;
 
-            var libraryRect = new Rect(position.x, position.y, position.width, lineHeight);
-            EditorGUI.BeginChangeCheck();
-            EditorGUI.PropertyField(libraryRect, libraryProp, label);
-            var libraryChanged = EditorGUI.EndChangeCheck();
+            var idRect = new Rect(position.x, position.y, position.width, lineHeight);
+            DrawIdPicker(idRect, library, idProp, label);
 
-            using(new EditorGUI.IndentLevelScope()) {
-                var idRect = new Rect(position.x, position.y + lineHeight + spacing, position.width, lineHeight);
-                DrawIdPicker(idRect, libraryProp, idProp, libraryChanged);
+            var inlineRect = new Rect(
+                position.x,
+                position.y + lineHeight + spacing,
+                position.width,
+                lineHeight * 2);
+            EditorGUI.PropertyField(inlineRect, inlineProp, new GUIContent("Inline"));
 
-                var inlineRect = new Rect(
-                    position.x,
-                    position.y + (lineHeight + spacing) * 2,
-                    position.width,
-                    lineHeight * 2);
-                EditorGUI.PropertyField(inlineRect, inlineProp, new GUIContent("Inline"));
-
-                var previewRect = new Rect(
-                    position.x,
-                    position.y + (lineHeight + spacing) * 2 + lineHeight * 2 + spacing,
-                    position.width,
-                    PreviewHeight);
-                DrawPreview(previewRect, libraryProp, idProp, inlineProp);
-            }
+            var previewRect = new Rect(
+                position.x,
+                position.y + lineHeight + spacing + lineHeight * 2 + spacing,
+                position.width,
+                PreviewHeight);
+            DrawPreview(previewRect, library, idProp, inlineProp);
 
             EditorGUI.EndProperty();
         }
@@ -54,18 +43,19 @@ namespace Jovian.EncounterSystem.Editor {
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label) {
             var lineHeight = EditorGUIUtility.singleLineHeight;
             var spacing = EditorGUIUtility.standardVerticalSpacing;
-            // library + id + (inline 2 lines) + preview
-            return (lineHeight + spacing) * 2 + lineHeight * 2 + spacing + PreviewHeight;
+            // id + (inline 2 lines) + preview
+            return lineHeight + spacing + lineHeight * 2 + spacing + PreviewHeight;
         }
 
-        private static void DrawIdPicker(Rect rect, SerializedProperty libraryProp, SerializedProperty idProp, bool libraryChanged) {
-            var library = libraryProp.objectReferenceValue as DialogLineLibrary;
+        private static DialogLineLibrary ResolveLibrary(SerializedProperty property) {
+            var libraryProp = property.serializedObject.FindProperty("library");
+            return libraryProp?.objectReferenceValue as DialogLineLibrary;
+        }
+
+        private static void DrawIdPicker(Rect rect, DialogLineLibrary library, SerializedProperty idProp, GUIContent label) {
             if(library == null || library.lines == null || library.lines.Count == 0) {
                 using(new EditorGUI.DisabledScope(true)) {
-                    EditorGUI.Popup(rect, "Id", 0, new[] { EmptyLibraryPlaceholder });
-                }
-                if(libraryChanged) {
-                    idProp.stringValue = string.Empty;
+                    EditorGUI.Popup(rect, label.text, 0, new[] { EmptyLibraryPlaceholder });
                 }
                 return;
             }
@@ -82,24 +72,18 @@ namespace Jovian.EncounterSystem.Editor {
                 var id = line?.id ?? string.Empty;
                 ids[i + 1] = id;
                 names[i + 1] = string.IsNullOrEmpty(id) ? $"<unnamed {i}>" : id;
-                if(!libraryChanged && id == idProp.stringValue && !string.IsNullOrEmpty(id)) {
+                if(id == idProp.stringValue && !string.IsNullOrEmpty(id)) {
                     currentIndex = i + 1;
                 }
             }
 
-            if(libraryChanged) {
-                idProp.stringValue = string.Empty;
-                currentIndex = 0;
-            }
-
-            var newIndex = EditorGUI.Popup(rect, "Id", currentIndex, names);
+            var newIndex = EditorGUI.Popup(rect, label.text, currentIndex, names);
             if(newIndex != currentIndex) {
                 idProp.stringValue = ids[newIndex];
             }
         }
 
-        private static void DrawPreview(Rect rect, SerializedProperty libraryProp, SerializedProperty idProp, SerializedProperty inlineProp) {
-            var library = libraryProp.objectReferenceValue as DialogLineLibrary;
+        private static void DrawPreview(Rect rect, DialogLineLibrary library, SerializedProperty idProp, SerializedProperty inlineProp) {
             var id = idProp.stringValue;
             var inline = inlineProp.stringValue;
 
diff --git a/Editor/EncounterBrowserWindow.cs b/Editor/EncounterBrowserWindow.cs
index 9deb9b9..3aea7ea 100644
--- a/Editor/EncounterBrowserWindow.cs
+++ b/Editor/EncounterBrowserWindow.cs
@@ -8,11 +8,7 @@ using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>
-    /// Designer-facing browser for every <see cref="IEncounter"/> authored across all
-    /// <see cref="EncounterTable"/> assets in the project. Virtualised ListView on the left,
-    /// property-field detail pane on the right. Search by id/name/description; filter by kind.
-    /// </summary>
+    /// <summary>Browser for every encounter across all tables. Search + kind filter + detail pane. Quest chains render as a tree rooted at the first step.</summary>
     public class EncounterBrowserWindow : EditorWindow {
         private const string AllKinds = "All";
 
@@ -23,13 +19,12 @@ namespace Jovian.EncounterSystem.Editor {
         }
 
         private readonly List<Record> allRecords = new();
-        private List<Record> filteredRecords = new();
         private string searchText = string.Empty;
         private string kindFilter = AllKinds;
 
         private readonly Dictionary<IEncounter, List<ValidationIssue>> issuesByEncounter = new();
 
-        private ListView listView;
+        private TreeView treeView;
         private VisualElement detailPane;
         private ToolbarMenu kindDropdown;
 
@@ -78,15 +73,15 @@ namespace Jovian.EncounterSystem.Editor {
             split.style.flexGrow = 1f;
             rootVisualElement.Add(split);
 
-            listView = new ListView {
+            treeView = new TreeView {
                 makeItem = MakeRow,
                 bindItem = BindRow,
                 fixedItemHeight = 22,
                 selectionType = SelectionType.Single
             };
-            listView.selectionChanged += OnSelectionChanged;
-            listView.style.flexGrow = 1f;
-            split.Add(listView);
+            treeView.selectionChanged += OnSelectionChanged;
+            treeView.style.flexGrow = 1f;
+            split.Add(treeView);
 
             detailPane = new ScrollView(ScrollViewMode.Vertical) {
                 style = { paddingLeft = 8, paddingTop = 8, paddingRight = 8, flexGrow = 1f }
@@ -134,7 +129,7 @@ namespace Jovian.EncounterSystem.Editor {
         }
 
         private void BindRow(VisualElement element, int index) {
-            var record = filteredRecords[index];
+            var record = treeView.GetItemDataForIndex<Record>(index);
             var label = element.Q<Label>("row-label");
             var badge = element.Q<VisualElement>("issue-badge");
 
@@ -222,15 +217,73 @@ namespace Jovian.EncounterSystem.Editor {
         }
 
         private void ApplyFilter() {
-            filteredRecords = allRecords.Where(Matches).ToList();
-            if(listView != null) {
-                listView.itemsSource = filteredRecords;
-                listView.Rebuild();
-                listView.ClearSelection();
+            var filtered = allRecords.Where(Matches).ToList();
+            var items = BuildTreeItems(filtered);
+            if(treeView != null) {
+                treeView.SetRootItems(items);
+                treeView.Rebuild();
+                treeView.ClearSelection();
+                treeView.ExpandAll();
             }
             ShowEmptyDetail();
         }
 
+        private static List<TreeViewItemData<Record>> BuildTreeItems(List<Record> records) {
+            var byEncounter = new Dictionary<IEncounter, Record>();
+            foreach(var r in records) {
+                if(r.encounter != null) {
+                    byEncounter[r.encounter] = r;
+                }
+            }
+
+            // Any encounter that is a `nextEncounter` target of another record in the filtered set
+            // becomes a non-root (rendered as a child), not a top-level item.
+            var nonRoot = new HashSet<IEncounter>();
+            foreach(var r in records) {
+                if(r.encounter?.Kind is not QuestKind quest) {
+                    continue;
+                }
+                var next = quest.nextEncounter.Resolve();
+                if(next != null && byEncounter.ContainsKey(next)) {
+                    nonRoot.Add(next);
+                }
+            }
+
+            var result = new List<TreeViewItemData<Record>>();
+            var uid = 0;
+            foreach(var r in records) {
+                if(r.encounter != null && nonRoot.Contains(r.encounter)) {
+                    continue;
+                }
+
+                var children = BuildChainChildren(r, byEncounter, ref uid);
+                result.Add(new TreeViewItemData<Record>(uid++, r, children));
+            }
+            return result;
+        }
+
+        private static List<TreeViewItemData<Record>> BuildChainChildren(Record root, Dictionary<IEncounter, Record> byEncounter, ref int uid) {
+            var children = new List<TreeViewItemData<Record>>();
+            if(root.encounter?.Kind is not QuestKind) {
+                return children;
+            }
+
+            var current = root.encounter;
+            var visited = new HashSet<IEncounter> { current };
+            while(current?.Kind is QuestKind quest) {
+                var next = quest.nextEncounter.Resolve();
+                if(next == null || !visited.Add(next)) {
+                    break;
+                }
+                if(!byEncounter.TryGetValue(next, out var nextRecord)) {
+                    break;
+                }
+                children.Add(new TreeViewItemData<Record>(uid++, nextRecord));
+                current = next;
+            }
+            return children;
+        }
+
         private bool Matches(Record record) {
             var kindName = record.encounter?.Kind?.GetType().Name ?? string.Empty;
             if(kindFilter != AllKinds && kindName != kindFilter) {
diff --git a/Editor/EncounterDialogOptionDrawer.cs b/Editor/EncounterDialogOptionDrawer.cs
new file mode 100644
index 0000000..b3f3138
--- /dev/null
+++ b/Editor/EncounterDialogOptionDrawer.cs
@@ -0,0 +1,76 @@
+using Jovian.EncounterSystem;
+using UnityEditor;
+using UnityEngine;
+
+namespace Jovian.EncounterSystem.Editor {
+    /// <summary>Label list elements with the option's text id (fallback: inline text preview, then default).</summary>
+    [CustomPropertyDrawer(typeof(EncounterDialogOption))]
+    public class EncounterDialogOptionDrawer : PropertyDrawer {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) {
+            var displayLabel = ResolveLabel(property, label);
+
+            var foldoutRect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
+            property.isExpanded = EditorGUI.Foldout(foldoutRect, property.isExpanded, displayLabel, true);
+
+            if(!property.isExpanded) {
+                return;
+            }
+
+            EditorGUI.indentLevel++;
+            var y = position.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+            var iterator = property.Copy();
+            var end = iterator.GetEndProperty();
+            if(iterator.NextVisible(true)) {
+                while(!SerializedProperty.EqualContents(iterator, end)) {
+                    var h = EditorGUI.GetPropertyHeight(iterator, true);
+                    var r = new Rect(position.x, y, position.width, h);
+                    EditorGUI.PropertyField(r, iterator, true);
+                    y += h + EditorGUIUtility.standardVerticalSpacing;
+                    if(!iterator.NextVisible(false)) {
+                        break;
+                    }
+                }
+            }
+            EditorGUI.indentLevel--;
+        }
+
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label) {
+            var height = EditorGUIUtility.singleLineHeight;
+            if(!property.isExpanded) {
+                return height;
+            }
+
+            var iterator = property.Copy();
+            var end = iterator.GetEndProperty();
+            if(iterator.NextVisible(true)) {
+                while(!SerializedProperty.EqualContents(iterator, end)) {
+                    height += EditorGUI.GetPropertyHeight(iterator, true) + EditorGUIUtility.standardVerticalSpacing;
+                    if(!iterator.NextVisible(false)) {
+                        break;
+                    }
+                }
+            }
+            return height;
+        }
+
+        private static GUIContent ResolveLabel(SerializedProperty property, GUIContent fallback) {
+            var textProp = property.FindPropertyRelative("text");
+            if(textProp == null) {
+                return fallback;
+            }
+
+            var id = textProp.FindPropertyRelative("id")?.stringValue;
+            if(!string.IsNullOrEmpty(id)) {
+                return new GUIContent(id);
+            }
+
+            var inline = textProp.FindPropertyRelative("inlineText")?.stringValue;
+            if(!string.IsNullOrEmpty(inline)) {
+                var preview = inline.Length > 40 ? inline.Substring(0, 40) + "…" : inline;
+                return new GUIContent(preview);
+            }
+
+            return fallback;
+        }
+    }
+}
diff --git a/Editor/EncounterDrawer.cs b/Editor/EncounterDrawer.cs
index 7f0350c..4bc2547 100644
--- a/Editor/EncounterDrawer.cs
+++ b/Editor/EncounterDrawer.cs
@@ -3,11 +3,7 @@ using UnityEditor;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>
-    /// Draws each <see cref="Encounter"/> list element with its <see cref="EncounterDefinition.id"/>
-    /// as the foldout label (falling back to <c>name</c>, then the default element label).
-    /// Children are iterated manually to avoid recursing into this drawer.
-    /// </summary>
+    /// <summary>Label list elements with the encounter id (fallback: name, then default).</summary>
     [CustomPropertyDrawer(typeof(Encounter))]
     public class EncounterDrawer : PropertyDrawer {
         private const string DefinitionBackingField = "<EncounterDefinition>k__BackingField";
diff --git a/Editor/EncounterLinkDrawer.cs b/Editor/EncounterLinkDrawer.cs
index ac26d83..cbafe43 100644
--- a/Editor/EncounterLinkDrawer.cs
+++ b/Editor/EncounterLinkDrawer.cs
@@ -3,11 +3,7 @@ using UnityEditor;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>
-    /// Two-row drawer for <see cref="EncounterLink"/>. Row 1 is an asset object-field for the target
-    /// <see cref="EncounterTable"/>; row 2 is a dropdown of encounters inside that table labelled by
-    /// <c>EncounterDefinition.name</c>. Picking a different table clears the stored internalId.
-    /// </summary>
+    /// <summary>Table object-field + encounter dropdown picker. Changing tables clears the id.</summary>
     [CustomPropertyDrawer(typeof(EncounterLink))]
     public class EncounterLinkDrawer : PropertyDrawer {
         private const string NonePlaceholder = "<none>";
diff --git a/Editor/EncounterValidator.cs b/Editor/EncounterValidator.cs
index 0528b7e..9a7ede0 100644
--- a/Editor/EncounterValidator.cs
+++ b/Editor/EncounterValidator.cs
@@ -4,18 +4,11 @@ using UnityEditor;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>Severity of a <see cref="ValidationIssue"/>.</summary>
     public enum ValidationSeverity {
         Warning,
         Error
     }
 
-    /// <summary>
-    /// One thing the validator found wrong. <see cref="asset"/> is the click-through target
-    /// (table, dialog option set, reward), <see cref="encounter"/> identifies the specific
-    /// encounter the issue pertains to when applicable, and <see cref="path"/> describes where
-    /// inside the asset the issue lives.
-    /// </summary>
     public class ValidationIssue {
         public Object asset;
         public Encounter encounter;
@@ -24,13 +17,8 @@ namespace Jovian.EncounterSystem.Editor {
         public string message;
     }
 
-    /// <summary>
-    /// Scans every <see cref="EncounterTable"/> and <see cref="Reward"/> asset in the project and
-    /// returns the list of issues found. Intended to be driven from a menu item, the browser window,
-    /// or pre-commit tooling. Runs on demand — does not cache.
-    /// </summary>
+    /// <summary>Project-wide scan of encounter tables and rewards. Runs on demand, no caching.</summary>
     public static class EncounterValidator {
-        /// <summary>Walk every encounter table and reward asset, returning all issues found.</summary>
         public static List<ValidationIssue> ValidateProject() {
             var issues = new List<ValidationIssue>();
 
@@ -48,7 +36,6 @@ namespace Jovian.EncounterSystem.Editor {
             return issues;
         }
 
-        /// <summary>Return the issues for a single encounter inside a table. Useful for per-row badges.</summary>
         public static List<ValidationIssue> ValidateEncounter(EncounterTable table, int index) {
             var issues = new List<ValidationIssue>();
             if(table?.encounters == null || index < 0 || index >= table.encounters.Count) {
@@ -197,38 +184,39 @@ namespace Jovian.EncounterSystem.Editor {
         }
 
         private static void ValidateDialogLineRef(EncounterDialogOptionSet optionSet, Encounter encounter, string path, DialogLineRef lineRef, List<ValidationIssue> issues) {
-            var hasLibrary = lineRef.library != null;
+            var library = optionSet.library;
             var hasId = !string.IsNullOrEmpty(lineRef.id);
             var hasInline = !string.IsNullOrEmpty(lineRef.inlineText);
 
-            if(!hasLibrary && !hasInline) {
+            if(!hasId && !hasInline) {
                 issues.Add(new ValidationIssue {
                     asset = optionSet,
                     encounter = encounter,
                     path = path,
                     severity = ValidationSeverity.Warning,
-                    message = "Dialog line is empty (no library reference and no inline text)."
+                    message = "Dialog line is empty (no id and no inline text)."
                 });
                 return;
             }
 
-            if(hasLibrary && hasId && string.IsNullOrEmpty(lineRef.library.Resolve(lineRef.id))) {
+            if(hasId && library == null) {
                 issues.Add(new ValidationIssue {
                     asset = optionSet,
                     encounter = encounter,
                     path = path,
                     severity = ValidationSeverity.Error,
-                    message = $"DialogLineRef id '{lineRef.id}' not found in library '{lineRef.library.name}'."
+                    message = $"DialogLineRef references id '{lineRef.id}' but the option set has no library assigned."
                 });
+                return;
             }
 
-            if(hasLibrary && !hasId && !hasInline) {
+            if(hasId && library != null && string.IsNullOrEmpty(library.Resolve(lineRef.id))) {
                 issues.Add(new ValidationIssue {
                     asset = optionSet,
                     encounter = encounter,
                     path = path,
-                    severity = ValidationSeverity.Warning,
-                    message = "Library assigned but no id picked; will fall back to empty inline text."
+                    severity = ValidationSeverity.Error,
+                    message = $"DialogLineRef id '{lineRef.id}' not found in library '{library.name}'."
                 });
             }
         }
@@ -271,7 +259,6 @@ namespace Jovian.EncounterSystem.Editor {
         }
     }
 
-    /// <summary>Menu-driven runner that prints the validator report to the console with click-through asset pings.</summary>
     public static class EncounterValidatorMenu {
         [MenuItem("Jovian/Encounters/Validate All")]
         public static void ValidateAll() {
diff --git a/Editor/SubclassSelectorDrawer.cs b/Editor/SubclassSelectorDrawer.cs
index 69a4a68..0232489 100644
--- a/Editor/SubclassSelectorDrawer.cs
+++ b/Editor/SubclassSelectorDrawer.cs
@@ -6,16 +6,7 @@ using UnityEditor;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem.Editor {
-    /// <summary>
-    /// Custom drawer for any field marked <c>[SerializeReference, SubclassSelector]</c>. Renders a
-    /// "pick a concrete type" dropdown populated by reflection over the declared base type, then
-    /// draws the chosen instance's serialized children underneath. Works for single fields, arrays,
-    /// and <see cref="List{T}"/> elements.
-    /// </summary>
-    /// <remarks>
-    /// The type cache is a <c>static readonly</c> dictionary; it is implicitly cleared on domain
-    /// reload because the static field is recreated with the new assembly image.
-    /// </remarks>
+    /// <summary>Concrete-type dropdown for <c>[SerializeReference]</c> fields, arrays, and list elements.</summary>
     [CustomPropertyDrawer(typeof(SubclassSelectorAttribute))]
     public class SubclassSelectorDrawer : PropertyDrawer {
         private static readonly Dictionary<Type, Type[]> TypeCache = new();
diff --git a/Runtime/DialogLineLibrary.cs b/Runtime/DialogLineLibrary.cs
index 7be5ec3..8f266e6 100644
--- a/Runtime/DialogLineLibrary.cs
+++ b/Runtime/DialogLineLibrary.cs
@@ -3,30 +3,19 @@ using System.Collections.Generic;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>One dialog line — an id/text pair in a <see cref="DialogLineLibrary"/>.</summary>
     [Serializable]
     public class DialogLine {
-        /// <summary>Stable key referenced by <see cref="DialogLineRef"/> (e.g. "common.farewell").</summary>
         public string id;
-
-        /// <summary>The actual text shown to the player.</summary>
-        [TextArea(2, 6)]
-        public string text;
+        [TextArea(2, 6)] public string text;
     }
 
-    /// <summary>
-    /// Single-asset registry of reusable dialog lines. One library file holds many lines; dialog
-    /// options reference them by id via <see cref="DialogLineRef"/>. Split into multiple libraries
-    /// (e.g. CommonLines, TownDialogue) only when a single file becomes unwieldy.
-    /// </summary>
+    /// <summary>Flat registry of reusable dialog lines. Referenced via <see cref="DialogLineRef"/>.</summary>
     [CreateAssetMenu(fileName = "DialogLineLibrary", menuName = "Jovian/Encounter System/Dialog Line Library", order = 4)]
     public class DialogLineLibrary : ScriptableObject {
-        /// <summary>All lines in the library.</summary>
         public List<DialogLine> lines = new();
 
         private Dictionary<string, string> cache;
 
-        /// <summary>Return the text for <paramref name="id"/>, or <c>null</c> if not found.</summary>
         public string Resolve(string id) {
             if(string.IsNullOrEmpty(id)) {
                 return null;
@@ -36,8 +25,6 @@ namespace Jovian.EncounterSystem {
             return cache.TryGetValue(id, out var text) ? text : null;
         }
 
-        /// <summary>Force the next <see cref="Resolve"/> call to rebuild the id → text cache.
-        /// Called automatically from <c>OnValidate</c> after inspector edits.</summary>
         public void InvalidateCache() {
             cache = null;
         }
diff --git a/Runtime/DialogLineRef.cs b/Runtime/DialogLineRef.cs
index 98a4b8c..dc4da81 100644
--- a/Runtime/DialogLineRef.cs
+++ b/Runtime/DialogLineRef.cs
@@ -2,28 +2,13 @@ using System;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Reference to a dialog line. Looks up <see cref="id"/> inside <see cref="library"/> when both
-    /// are set; otherwise falls back to <see cref="inlineText"/>. This lets designers prototype
-    /// one-off lines inline and promote common ones to the shared library later without changing
-    /// the field's type.
-    /// </summary>
+    /// <summary>Looks up <see cref="id"/> in the library passed to <see cref="Resolve"/>; falls back to <see cref="inlineText"/>.</summary>
     [Serializable]
     public struct DialogLineRef {
-        /// <summary>Shared library to resolve <see cref="id"/> against. Optional.</summary>
-        public DialogLineLibrary library;
-
-        /// <summary>Line id inside <see cref="library"/>. Ignored if <see cref="library"/> is null.</summary>
         public string id;
+        [TextArea(2, 6)] public string inlineText;
 
-        /// <summary>Fallback text used when the library reference is missing or fails to resolve.
-        /// Authored directly in the inspector for one-off lines.</summary>
-        [TextArea(2, 6)]
-        public string inlineText;
-
-        /// <summary>Resolve to final text. Returns <see cref="inlineText"/> if no library reference
-        /// resolves, or <c>null</c> if both paths yield nothing.</summary>
-        public string Resolve() {
+        public string Resolve(DialogLineLibrary library) {
             if(library != null && !string.IsNullOrEmpty(id)) {
                 var text = library.Resolve(id);
                 if(!string.IsNullOrEmpty(text)) {
diff --git a/Runtime/EncounterContext.cs b/Runtime/EncounterContext.cs
index 95b1deb..55bbea9 100644
--- a/Runtime/EncounterContext.cs
+++ b/Runtime/EncounterContext.cs
@@ -1,11 +1,6 @@
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Per-resolution state passed into every event handler invoked by <see cref="EncounterResolver.Resolve"/>.
-    /// Holds "who/what is currently being resolved" — not long-lived services. Extend with additional
-    /// fields (party, selected option, acting character, …) as handlers need them.
-    /// </summary>
+    /// <summary>Per-resolution scratch object passed to every event handler. Extend with fields as handlers need them.</summary>
     public class EncounterContext {
-        /// <summary>The encounter whose dialog option fired this resolution.</summary>
         public IEncounter CurrentEncounter { get; }
 
         public EncounterContext(IEncounter currentEncounter) {
diff --git a/Runtime/EncounterDialogOptionSet.cs b/Runtime/EncounterDialogOptionSet.cs
index bbb4160..5bba2d9 100644
--- a/Runtime/EncounterDialogOptionSet.cs
+++ b/Runtime/EncounterDialogOptionSet.cs
@@ -2,17 +2,14 @@ using System.Collections.Generic;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Reusable asset containing the dialog options shown for an encounter. Stored as an asset so a
-    /// single set can be shared across encounters when the same choices apply. When <see cref="id"/>
-    /// changes the asset file auto-renames to match (editor-only).
-    /// </summary>
+    /// <summary>Reusable dialog option list. Asset file auto-renames to match <see cref="id"/>.</summary>
     [CreateAssetMenu(fileName = "EncounterDialogOptionSet", menuName = "Jovian/Encounter System/Dialog Option Set", order = 2)]
     public class EncounterDialogOptionSet : ScriptableObject {
-        /// <summary>Designer-facing identifier for this option set. The asset file renames to match.</summary>
         public string id;
 
-        /// <summary>Ordered list of options presented to the player.</summary>
+        /// <summary>Shared library for every option's <see cref="EncounterDialogOption.text"/> lookup.</summary>
+        public DialogLineLibrary library;
+
         public List<EncounterDialogOption> options;
 
 #if UNITY_EDITOR
@@ -21,7 +18,7 @@ namespace Jovian.EncounterSystem {
                 return;
             }
 
-            // Deferred — AssetDatabase calls are unsafe from OnValidate.
+            // AssetDatabase calls are unsafe from OnValidate — defer.
             UnityEditor.EditorApplication.delayCall += RenameToMatchId;
         }
 
@@ -31,10 +28,7 @@ namespace Jovian.EncounterSystem {
             }
 
             var path = UnityEditor.AssetDatabase.GetAssetPath(this);
-            if(string.IsNullOrEmpty(path)) {
-                return;
-            }
-            if(name == id) {
+            if(string.IsNullOrEmpty(path) || name == id) {
                 return;
             }
 
diff --git a/Runtime/EncounterLink.cs b/Runtime/EncounterLink.cs
index d5bc9ce..5e33563 100644
--- a/Runtime/EncounterLink.cs
+++ b/Runtime/EncounterLink.cs
@@ -1,21 +1,12 @@
 using System;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Cross-table reference to an <see cref="IEncounter"/>. Stores the owning
-    /// <see cref="EncounterTable"/> asset and the target encounter's <see cref="EncounterDefinition.internalId"/>.
-    /// Rename-safe because the stored key is a GUID.
-    /// </summary>
+    /// <summary>Cross-table reference. Rename-safe — the stored key is a GUID.</summary>
     [Serializable]
     public struct EncounterLink {
-        /// <summary>The table that owns the linked encounter.</summary>
         public EncounterTable table;
-
-        /// <summary>The target encounter's stable GUID (<see cref="EncounterDefinition.internalId"/>).</summary>
         public string internalId;
 
-        /// <summary>Look up the referenced encounter, or <c>null</c> if the table is missing or the id
-        /// no longer exists in it.</summary>
         public IEncounter Resolve() {
             if(table == null || table.encounters == null || string.IsNullOrEmpty(internalId)) {
                 return null;
diff --git a/Runtime/EncounterReference.cs b/Runtime/EncounterReference.cs
index c110fdc..cd4dd89 100644
--- a/Runtime/EncounterReference.cs
+++ b/Runtime/EncounterReference.cs
@@ -3,11 +3,7 @@ using UnityEngine;
 using UnityEngine.UI;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Scene-side view scaffold for presenting an encounter. Provides wired-up references to the
-    /// common UI widgets (name/description/art/options container/submit button) so a game-specific
-    /// view controller can bind an <see cref="IEncounter"/> to them without duplicating boilerplate.
-    /// </summary>
+    /// <summary>Shared view scaffold — game code binds an <see cref="IEncounter"/> to these widgets.</summary>
     public class EncounterReference : MonoBehaviour {
         public TextMeshProUGUI encounterName;
         public TextMeshProUGUI encounterDescription;
diff --git a/Runtime/EncounterRegistry.cs b/Runtime/EncounterRegistry.cs
index 4cd3041..4b45c16 100644
--- a/Runtime/EncounterRegistry.cs
+++ b/Runtime/EncounterRegistry.cs
@@ -4,39 +4,27 @@ using UnityEngine;
 using UnityEngine.AddressableAssets;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Central lookup cache mapping <see cref="EncounterDefinition.internalId"/> to its owning
-    /// <see cref="IEncounter"/> across one or more <see cref="EncountersCollection"/> assets.
-    /// In editor the registry auto-populates via an asset postprocessor; at runtime call
-    /// <see cref="PopulateEncounters"/> explicitly after load.
-    /// </summary>
+    /// <summary>id → encounter cache. Editor auto-repopulates on asset changes; runtime must call <see cref="PopulateEncounters"/>.</summary>
     [CreateAssetMenu(fileName = "EncounterRegistry", menuName = "Jovian/Encounter System/Encounter Registry")]
     public class EncounterRegistry : ScriptableObject {
-        /// <summary>Collections whose encounters should be indexed.</summary>
         public EncountersCollection[] encounterCollections = Array.Empty<EncountersCollection>();
 
         private readonly Dictionary<string, IEncounter> encounters = new();
 
-        /// <summary>The live id → encounter map.</summary>
         public Dictionary<string, IEncounter> GetEncounters() => encounters;
 
-        /// <summary>Add an encounter to the cache if its id isn't already present.</summary>
         public void RegisterEncounter(IEncounter encounter) {
             encounters?.TryAdd(encounter?.EncounterDefinition?.internalId, encounter);
         }
 
-        /// <summary>Remove an encounter from the cache by its id.</summary>
         public void UnregisterEncounter(IEncounter encounter) {
             encounters.Remove(encounter.EncounterDefinition.internalId);
         }
 
-        /// <summary>Clear the cache. Call before a full re-population to avoid stale entries.</summary>
         public void ClearEncounters() {
             encounters.Clear();
         }
 
-        /// <summary>Walk <see cref="encounterCollections"/> and register every encounter found.
-        /// Call <see cref="ClearEncounters"/> first if you need a clean state.</summary>
         public void PopulateEncounters() {
             foreach(var collection in encounterCollections) {
                 foreach(var encounter in collection.encounterTables) {
@@ -49,11 +37,7 @@ namespace Jovian.EncounterSystem {
     }
 
 #if UNITY_EDITOR
-    /// <summary>
-    /// Editor-time hook that keeps an <see cref="EncounterRegistry"/> asset (located via Addressables
-    /// key <c>"EncounterRegistry"</c>) in sync with asset edits: clears and repopulates on any asset
-    /// import/move/delete.
-    /// </summary>
+    /// <summary>Rebuilds the registry (Addressables key "EncounterRegistry") on any asset import/move/delete.</summary>
     public class EncounterRegister : UnityEditor.AssetPostprocessor {
         private static EncounterRegistry registryCache;
 
diff --git a/Runtime/EncounterResolver.cs b/Runtime/EncounterResolver.cs
index e72a49d..6ee5365 100644
--- a/Runtime/EncounterResolver.cs
+++ b/Runtime/EncounterResolver.cs
@@ -2,34 +2,20 @@ using System;
 using System.Collections.Generic;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Dispatches <see cref="IEncounterEvent"/> instances (authored on dialog options) to per-type
-    /// handlers registered at composition time. Unknown event types are silently skipped.
-    /// </summary>
-    /// <remarks>
-    /// The resolver stores handlers keyed by concrete event <see cref="Type"/>. Registration wraps a
-    /// typed delegate in a closure that casts back to the concrete type — the cast is safe because
-    /// we only ever invoke the wrapped delegate via the dictionary lookup under the same key.
-    /// </remarks>
+    /// <summary>Dispatches <see cref="IEncounterEvent"/> instances to per-type handlers. Unknown types are skipped.</summary>
     public class EncounterResolver {
         private readonly Dictionary<Type, Action<IEncounterEvent, EncounterContext>> handlers = new();
 
-        /// <summary>Register a handler for a concrete event type. Replaces any prior registration.</summary>
-        /// <typeparam name="T">The event type to handle.</typeparam>
-        /// <param name="handler">The delegate invoked with the cast event and the resolution context.</param>
         public void Register<T>(Action<T, EncounterContext> handler) where T : IEncounterEvent {
+            // Wrap the typed delegate so the dictionary can hold handlers for any event type uniformly.
+            // Cast is safe because the wrapper is only invoked via lookup under typeof(T).
             handlers[typeof(T)] = (evt, ctx) => handler((T)evt, ctx);
         }
 
-        /// <summary>Remove the handler registered for event type <typeparamref name="T"/>, if any.</summary>
         public void Unregister<T>() where T : IEncounterEvent {
             handlers.Remove(typeof(T));
         }
 
-        /// <summary>Dispatch each event in <paramref name="events"/> to its registered handler, in order.
-        /// Null events and events with no registered handler are skipped.</summary>
-        /// <param name="events">The ordered event list (typically from an <see cref="EncounterDialogOption"/>).</param>
-        /// <param name="context">Per-resolution context passed to every handler.</param>
         public void Resolve(IEnumerable<IEncounterEvent> events, EncounterContext context) {
             if(events == null) {
                 return;
diff --git a/Runtime/EncounterTable.cs b/Runtime/EncounterTable.cs
index 011518d..a0e3c09 100644
--- a/Runtime/EncounterTable.cs
+++ b/Runtime/EncounterTable.cs
@@ -3,22 +3,11 @@ using System.Collections.Generic;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// A ScriptableObject asset holding a named list of encounters. Encounters inside the list are
-    /// authored via <c>[SerializeReference]</c> so different <see cref="IEncounter"/> implementations
-    /// and <see cref="IEncounterKind"/> payloads can coexist.
-    /// </summary>
     [CreateAssetMenu(fileName = "EncounterTable", menuName = "Jovian/Encounter System/Encounter Table", order = 1)]
     public class EncounterTable : ScriptableObject {
-        /// <summary>Designer-facing table identifier (free-form).</summary>
         public string id;
-
-        /// <summary>Ordered encounter list. Each element is a concrete <see cref="Encounter"/> whose
-        /// type-specific payload is carried by its <see cref="IEncounterKind"/> (set in the inspector
-        /// via the SubclassSelector dropdown on <see cref="Encounter.Kind"/>).</summary>
         public List<Encounter> encounters;
 
-        /// <summary>Pick a uniformly random encounter, or <c>null</c> if the table is empty.</summary>
         public IEncounter GetRandomEncounter() {
             if(encounters == null || encounters.Count == 0) {
                 return null;
@@ -27,9 +16,6 @@ namespace Jovian.EncounterSystem {
             return encounters[UnityEngine.Random.Range(0, encounters.Count)];
         }
 
-        /// <summary>Pick a uniformly random encounter whose runtime type matches <paramref name="type"/>,
-        /// or <c>null</c> if none match.</summary>
-        /// <param name="type">The concrete <see cref="IEncounter"/> runtime type to filter on.</param>
         public IEncounter GetRandomEncounter(Type type) {
             if(encounters == null || encounters.Count == 0) {
                 return null;
@@ -43,10 +29,7 @@ namespace Jovian.EncounterSystem {
             return null;
         }
 
-        /// <summary>Pick a uniformly random encounter matching <paramref name="filter"/>, or <c>null</c>
-        /// if no element passes. Used by <see cref="QuestProgress.IsGated"/> integration to exclude
-        /// gated quest encounters from rolls.</summary>
-        /// <param name="filter">Predicate applied to each encounter before rolling.</param>
+        /// <summary>Random pick limited by a predicate. Used with <see cref="QuestProgress.IsGated"/> to exclude gated encounters.</summary>
         public IEncounter GetRandomEncounter(Predicate<IEncounter> filter) {
             if(encounters == null || encounters.Count == 0 || filter == null) {
                 return GetRandomEncounter();
diff --git a/Runtime/EncountersCollection.cs b/Runtime/EncountersCollection.cs
index fbdaa52..e0f8463 100644
--- a/Runtime/EncountersCollection.cs
+++ b/Runtime/EncountersCollection.cs
@@ -1,13 +1,8 @@
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Top-level asset that groups multiple <see cref="EncounterTable"/> references into a single
-    /// browsable unit. Pass one of these to <see cref="QuestProgress"/> to seed its gating graph.
-    /// </summary>
     [CreateAssetMenu(fileName = "EncountersCollection", menuName = "Jovian/Encounter System/Encounters Collection", order = 0)]
     public class EncountersCollection : ScriptableObject {
-        /// <summary>The tables grouped by this collection.</summary>
         public EncounterTable[] encounterTables;
     }
 }
diff --git a/Runtime/IEncounter.cs b/Runtime/IEncounter.cs
index 38cc2a9..8770970 100644
--- a/Runtime/IEncounter.cs
+++ b/Runtime/IEncounter.cs
@@ -3,32 +3,15 @@ using System.Collections.Generic;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Runtime contract for any encounter authored in the system.
-    /// An encounter aggregates designer-facing metadata, visuals, dialog, and a polymorphic
-    /// <see cref="IEncounterKind"/> payload that expresses its type-specific data.
-    /// </summary>
     public interface IEncounter {
-        /// <summary>Stable identity, display name, and designer description.</summary>
         EncounterDefinition EncounterDefinition { get; set; }
-
-        /// <summary>Numeric configuration shared by every encounter kind.</summary>
         EncounterProperties EncounterProperties { get; set; }
-
-        /// <summary>Visual assets displayed when the encounter is presented.</summary>
         EncounterVisuals EncounterVisuals { get; set; }
-
-        /// <summary>Dialog options shown to the player, or <c>null</c> if the encounter has no dialog.</summary>
         EncounterDialogOptionSet EncounterDialogOptionSet { get; set; }
-
-        /// <summary>Type-specific payload (combat, quest, social, ...). Authored via the SubclassSelector drawer.</summary>
         IEncounterKind Kind { get; set; }
     }
 
-    /// <summary>
-    /// Default concrete encounter. Holds the shared fields and a polymorphic <see cref="IEncounterKind"/>.
-    /// Prefer adding new behaviour by introducing a new <see cref="IEncounterKind"/> rather than subclassing this type.
-    /// </summary>
+    /// <summary>Default concrete encounter. Extend via a new <see cref="IEncounterKind"/>, not by subclassing.</summary>
     [Serializable]
     public class Encounter : IEncounter {
         [field: SerializeField] public EncounterDefinition EncounterDefinition { get; set; }
@@ -40,43 +23,25 @@ namespace Jovian.EncounterSystem {
         public IEncounterKind Kind { get; set; }
     }
 
-    /// <summary>
-    /// Designer-facing identity for an encounter. <see cref="internalId"/> is the stable GUID used for
-    /// cross-references (<see cref="EncounterLink"/>, quest progress, save data); <see cref="id"/> is a
-    /// human-readable slug; <see cref="name"/> and <see cref="description"/> are display strings.
-    /// </summary>
     [Serializable]
     public class EncounterDefinition {
-        /// <summary>Stable GUID, assigned once at creation. Never edit manually.</summary>
+        /// <summary>Stable GUID assigned at creation. Never edit manually.</summary>
         [HideInInspector]
         public string internalId = Guid.NewGuid().ToString();
 
-        /// <summary>Designer-authored short slug (e.g. "goblin_ambush").</summary>
         public string id;
-
-        /// <summary>Display name shown to the player.</summary>
         public string name;
-
-        /// <summary>Flavour text shown when the encounter opens.</summary>
         public string description;
     }
 
-    /// <summary>
-    /// A single choice presented to the player inside an <see cref="EncounterDialogOptionSet"/>.
-    /// Events fire in order when the option is picked and are dispatched through <see cref="EncounterResolver"/>.
-    /// </summary>
     [Serializable]
     public class EncounterDialogOption {
-        /// <summary>Option text shown in the UI. Resolved through a shared
-        /// <see cref="DialogLineLibrary"/> or falls back to inline text.</summary>
         public DialogLineRef text;
 
-        /// <summary>Ordered events executed by the resolver when this option is chosen.</summary>
         [SerializeReference, SubclassSelector]
         public List<IEncounterEvent> events;
     }
 
-    /// <summary>Visual assets for an encounter.</summary>
     [Serializable]
     public class EncounterVisuals {
         public Sprite icon;
@@ -84,7 +49,6 @@ namespace Jovian.EncounterSystem {
         public Sprite encounterArt;
     }
 
-    /// <summary>Numeric/tuning configuration shared across every encounter kind.</summary>
     [Serializable]
     public class EncounterProperties {
         public int difficulty;
diff --git a/Runtime/IEncounterEvent.cs b/Runtime/IEncounterEvent.cs
index 9b7f3f9..482b91f 100644
--- a/Runtime/IEncounterEvent.cs
+++ b/Runtime/IEncounterEvent.cs
@@ -1,38 +1,25 @@
 using System;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Marker interface for designer-authored dialog option side effects. Events carry data only;
-    /// behaviour is registered on <see cref="EncounterResolver"/> and dispatched by concrete type.
-    /// Add a new event by creating a new <see cref="IEncounterEvent"/> implementation and registering
-    /// a handler for it with the resolver.
-    /// </summary>
+    /// <summary>Data-only dialog option side effect. Handlers are registered on <see cref="EncounterResolver"/>.</summary>
     public interface IEncounterEvent {
     }
 
-    /// <summary>Transitions the flow to another encounter identified by <see cref="nextEncounterId"/>.</summary>
     [Serializable]
     public class ChainToEncounterEvent : IEncounterEvent {
         public string nextEncounterId;
     }
 
-    /// <summary>Starts a combat encounter by id. Intended to be handled by the combat play mode.</summary>
     [Serializable]
     public class StartCombatEvent : IEncounterEvent {
         public string combatEncounterId;
     }
 
-    /// <summary>Writes a line to whatever log sink the resolver's handler is configured with. Useful for debugging.</summary>
     [Serializable]
     public class LogEvent : IEncounterEvent {
         public string message;
     }
 
-    /// <summary>
-    /// Grants the referenced <see cref="Reward"/> asset to the party. The actual application is
-    /// handled by a game-side delegate registered on <see cref="EncounterResolver"/>. Add multiple
-    /// <see cref="GiveRewardEvent"/>s to a dialog option's event list to grant multiple rewards.
-    /// </summary>
     [Serializable]
     public class GiveRewardEvent : IEncounterEvent {
         public Reward reward;
diff --git a/Runtime/IEncounterKind.cs b/Runtime/IEncounterKind.cs
index 7ae0cdc..725e5d1 100644
--- a/Runtime/IEncounterKind.cs
+++ b/Runtime/IEncounterKind.cs
@@ -1,31 +1,23 @@
 using System;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Marker interface for the polymorphic payload of an <see cref="IEncounter"/>.
-    /// Each concrete kind carries its own designer-facing data. Behaviour lives in resolvers
-    /// and play modes — kinds are pure data. Add new kinds by creating a new <see cref="IEncounterKind"/>
-    /// implementation; the SubclassSelector drawer will surface it automatically.
-    /// </summary>
+    /// <summary>Polymorphic payload on an <see cref="IEncounter"/>. Add a new kind by implementing
+    /// this interface; the SubclassSelector drawer surfaces it automatically.</summary>
     public interface IEncounterKind {
     }
 
-    /// <summary>Combat encounter: triggers combat play mode with the specified enemy group.</summary>
     [Serializable]
     public class CombatKind : IEncounterKind {
         public string enemyGroupId;
         public string rewardTableId;
     }
 
-    /// <summary>Quest encounter: a step in a quest chain. The <see cref="nextEncounter"/> link is what
-    /// <see cref="QuestProgress"/> walks to build the gated progression graph.</summary>
     [Serializable]
     public class QuestKind : IEncounterKind {
         public EncounterLink nextEncounter;
         public string questTitle;
     }
 
-    /// <summary>Dialogue-driven encounter with an NPC and optional faction reputation impact.</summary>
     [Serializable]
     public class SocialKind : IEncounterKind {
         public string npcId;
@@ -33,32 +25,27 @@ namespace Jovian.EncounterSystem {
         public int reputationDelta;
     }
 
-    /// <summary>Puzzle encounter gated by a skill check against <see cref="difficultyClass"/>.</summary>
     [Serializable]
     public class PuzzleKind : IEncounterKind {
         public string puzzleId;
         public int difficultyClass;
     }
 
-    /// <summary>Exploration/discovery encounter gated by a perception check (<see cref="perceptionDC"/>).</summary>
     [Serializable]
     public class ExplorationKind : IEncounterKind {
         public int perceptionDC;
     }
 
-    /// <summary>Tutorial encounter driving a tutorial subsystem by id.</summary>
     [Serializable]
     public class TutorialKind : IEncounterKind {
         public string tutorialId;
     }
 
-    /// <summary>Environmental hazard that applies damage or a status without player choice.</summary>
     [Serializable]
     public class HazardKind : IEncounterKind {
         public int damageAmount;
     }
 
-    /// <summary>Catch-all with no kind-specific data — useful while prototyping.</summary>
     [Serializable]
     public class OtherKind : IEncounterKind {
     }
diff --git a/Runtime/IRewardKind.cs b/Runtime/IRewardKind.cs
index cbc9342..c1060ca 100644
--- a/Runtime/IRewardKind.cs
+++ b/Runtime/IRewardKind.cs
@@ -1,45 +1,32 @@
 using System;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Marker interface for the polymorphic payload of a <see cref="Reward"/>.
-    /// Each concrete kind carries its own designer-facing data. Behaviour lives in a reward-applying
-    /// handler registered on <see cref="EncounterResolver"/> for <see cref="GiveRewardEvent"/> —
-    /// kinds are pure data. Add a new reward type by creating a new <see cref="IRewardKind"/>
-    /// implementation; the SubclassSelector drawer will surface it automatically.
-    /// </summary>
+    /// <summary>Polymorphic payload on a <see cref="Reward"/>. Add a new kind by implementing this interface.</summary>
     public interface IRewardKind {
     }
 
-    /// <summary>Grants an amount of a named currency (gold, silver, faction-specific scrip, ...).</summary>
     [Serializable]
     public class CurrencyRewardKind : IRewardKind {
         public string currencyId;
         public int amount;
     }
 
-    /// <summary>Grants one or more copies of an item identified by id.</summary>
     [Serializable]
     public class ItemRewardKind : IRewardKind {
         public string itemId;
         public int quantity;
     }
 
-    /// <summary>Grants experience points to the party or a specific recipient.</summary>
     [Serializable]
     public class ExperienceRewardKind : IRewardKind {
         public int amount;
     }
 
-    /// <summary>Unlocks something identified by id (recipe, area, journal entry, achievement, ...).
-    /// What is actually unlocked is decided by the game-side handler.</summary>
     [Serializable]
     public class UnlockableRewardKind : IRewardKind {
         public string unlockableId;
     }
 
-    /// <summary>Catch-all with no kind-specific data — useful for prototyping or one-off rewards
-    /// whose semantics are carried by the <see cref="Reward.id"/> alone.</summary>
     [Serializable]
     public class OtherRewardKind : IRewardKind {
     }
diff --git a/Runtime/QuestLog.cs b/Runtime/QuestLog.cs
index 0736e62..fbbbe7b 100644
--- a/Runtime/QuestLog.cs
+++ b/Runtime/QuestLog.cs
@@ -3,17 +3,12 @@ using System.Collections.Generic;
 using System.Linq;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>Tag for a quest log entry.</summary>
     public enum QuestLogEventType {
         Started,
         Advanced,
         Completed
     }
 
-    /// <summary>
-    /// One chronological entry in the quest log. Names are cached alongside ids so a loaded save
-    /// can display the log even if the underlying encounter has since been renamed or removed.
-    /// </summary>
     [Serializable]
     public class QuestLogEntry {
         public QuestLogEventType type;
@@ -23,34 +18,24 @@ namespace Jovian.EncounterSystem {
     }
 
     /// <summary>
-    /// Chronological, serializable record of quest events. Subscribes to <see cref="QuestProgress"/>
-    /// events at construction time — build it before any encounter fires so nothing is missed.
+    /// Chronological, serialisable record of quest events. Subscribes at construction —
+    /// build before any encounter fires or early entries will be missed.
     /// </summary>
-    /// <remarks>
-    /// This is the save payload for quest progression. On load, call <see cref="Restore"/> with the
-    /// saved entries and then <see cref="QuestProgress.LoadResolvedIds"/> with
-    /// <see cref="ResolvedEncounterIds"/> to rehydrate the gating set.
-    /// </remarks>
     public class QuestLog {
         private readonly List<QuestLogEntry> entries = new();
 
-        /// <summary>The log in chronological order.</summary>
         public IReadOnlyList<QuestLogEntry> Entries => entries;
 
-        /// <summary>Subscribe to <paramref name="progress"/>'s quest events; every fire appends an entry.</summary>
         public QuestLog(QuestProgress progress) {
             progress.QuestStarted += quest => Record(QuestLogEventType.Started, null, quest);
             progress.QuestAdvanced += (from, to) => Record(QuestLogEventType.Advanced, from, to);
             progress.QuestCompleted += quest => Record(QuestLogEventType.Completed, null, quest);
         }
 
-        /// <summary>Return a copy of the current entries suitable for serialization.</summary>
         public List<QuestLogEntry> CreateSnapshot() {
             return new List<QuestLogEntry>(entries);
         }
 
-        /// <summary>Replace the current entries with those from a save. Pass the list straight from
-        /// the save payload.</summary>
         public void Restore(IEnumerable<QuestLogEntry> saved) {
             entries.Clear();
             if(saved == null) {
@@ -60,8 +45,6 @@ namespace Jovian.EncounterSystem {
             entries.AddRange(saved);
         }
 
-        /// <summary>Enumerate the distinct encounter ids present in the log — what
-        /// <see cref="QuestProgress.LoadResolvedIds"/> needs on load.</summary>
         public IEnumerable<string> ResolvedEncounterIds() {
             return entries
                 .Select(entry => entry.encounterInternalId)
diff --git a/Runtime/QuestProgress.cs b/Runtime/QuestProgress.cs
index 710146f..68f7534 100644
--- a/Runtime/QuestProgress.cs
+++ b/Runtime/QuestProgress.cs
@@ -3,39 +3,24 @@ using System.Collections.Generic;
 
 namespace Jovian.EncounterSystem {
     /// <summary>
-    /// Tracks which <see cref="QuestKind"/> encounters the party has resolved and gates any quest
-    /// encounter whose predecessor hasn't fired yet. Consumers use <see cref="IsGated"/> to exclude
-    /// blocked encounters from rolls, and <see cref="OnEncounterTriggered"/> to mark progress.
+    /// Gated quest progression. Encounter E is gated iff some QuestKind encounter P has
+    /// <c>P.nextEncounter == E</c> and P hasn't been resolved. Predecessor map is built once at
+    /// construction; rolling and advancement are O(1).
     /// </summary>
-    /// <remarks>
-    /// Gating rule: encounter <c>E</c> is gated iff some other quest encounter <c>P</c> has
-    /// <c>P.nextEncounter == E</c> and <c>P</c> hasn't been resolved yet. Build the predecessor map
-    /// once in <c>IndexQuests</c>; rolling and advancement are both O(1).
-    /// </remarks>
     public class QuestProgress {
         private readonly HashSet<string> resolvedIds = new();
         private readonly Dictionary<string, IEncounter> predecessorOf = new();
 
-        /// <summary>Fires when a root quest encounter (no predecessor) is resolved.</summary>
         public event Action<IEncounter> QuestStarted;
-
-        /// <summary>Fires when a chained quest encounter is resolved. Args: (previous, current).</summary>
         public event Action<IEncounter, IEncounter> QuestAdvanced;
-
-        /// <summary>Fires when a quest encounter with no <c>nextEncounter</c> is resolved.</summary>
         public event Action<IEncounter> QuestCompleted;
 
-        /// <summary>Snapshot of every quest encounter id the party has resolved. Save this in the save file.</summary>
         public IReadOnlyCollection<string> ResolvedIds => resolvedIds;
 
-        /// <summary>Construct and index the quest graph from the given collection.</summary>
-        /// <param name="encountersCollection">The collection whose tables will be walked for quest chains.</param>
         public QuestProgress(EncountersCollection encountersCollection) {
             IndexQuests(encountersCollection);
         }
 
-        /// <summary>Returns <c>true</c> if the encounter is currently blocked because its quest
-        /// predecessor hasn't been resolved yet.</summary>
         public bool IsGated(IEncounter encounter) {
             var id = encounter?.EncounterDefinition?.internalId;
             if(string.IsNullOrEmpty(id)) {
@@ -49,9 +34,6 @@ namespace Jovian.EncounterSystem {
             return !resolvedIds.Contains(predecessor.EncounterDefinition.internalId);
         }
 
-        /// <summary>Inform the progress service that an encounter was just shown to the party.
-        /// Non-quest encounters and already-resolved ones are no-ops. Fires one or two of the
-        /// <see cref="QuestStarted"/>/<see cref="QuestAdvanced"/>/<see cref="QuestCompleted"/> events.</summary>
         public void OnEncounterTriggered(IEncounter encounter) {
             if(encounter?.Kind is not QuestKind questKind) {
                 return;
@@ -77,8 +59,6 @@ namespace Jovian.EncounterSystem {
             }
         }
 
-        /// <summary>Restore resolved quest ids from save data. Call after construction, before the
-        /// first <see cref="OnEncounterTriggered"/>.</summary>
         public void LoadResolvedIds(IEnumerable<string> ids) {
             resolvedIds.Clear();
             if(ids == null) {
diff --git a/Runtime/Reward.cs b/Runtime/Reward.cs
index 6576416..d0f4cba 100644
--- a/Runtime/Reward.cs
+++ b/Runtime/Reward.cs
@@ -1,21 +1,12 @@
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Authored reward asset. Designers create one file per reusable reward ("10 Gold", "Rusty Sword",
-    /// "Town Unlock: Riverfort") and reference it from <see cref="GiveRewardEvent"/> on dialog options.
-    /// The <see cref="kind"/> payload chooses the reward type; the enclosing asset carries identity
-    /// and presentation data shared across all types.
-    /// </summary>
+    /// <summary>Reusable reward asset referenced by <see cref="GiveRewardEvent"/>.</summary>
     [CreateAssetMenu(fileName = "Reward", menuName = "Jovian/Encounter System/Reward", order = 3)]
     public class Reward : ScriptableObject {
-        /// <summary>Designer-facing short slug (e.g. "gold_10").</summary>
         public string id;
-
-        /// <summary>Display name shown to the player when the reward is granted.</summary>
         public string displayName;
 
-        /// <summary>Type-specific payload (currency, item, experience, ...). Authored via the SubclassSelector drawer.</summary>
         [SerializeReference, SubclassSelector]
         public IRewardKind kind;
     }
diff --git a/Runtime/SubclassSelectorAttribute.cs b/Runtime/SubclassSelectorAttribute.cs
index 2c4b3ab..caea7ed 100644
--- a/Runtime/SubclassSelectorAttribute.cs
+++ b/Runtime/SubclassSelectorAttribute.cs
@@ -2,11 +2,7 @@ using System;
 using UnityEngine;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>
-    /// Marker attribute instructing the editor to render a concrete-type picker for a
-    /// <c>[SerializeReference]</c> field (or list/array element). The drawer scans the declared
-    /// base type's assembly for non-abstract implementations and offers them in a dropdown.
-    /// </summary>
+    /// <summary>Renders a concrete-type picker dropdown for a <c>[SerializeReference]</c> field.</summary>
     [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
     public class SubclassSelectorAttribute : PropertyAttribute {
     }