feat(objectstate): add saved resolved accessor and raw-dirty flag

Expose get_saved_resolved_value() to read from the saved resolved snapshot (_saved_resolved) instead of the live resolved cache, so callers can make decisions based on the last committed baseline even when UI edits exist.

Add is_raw_dirty as a fast raw-parameter dirty check (parameters vs _saved_parameters), and document the distinction between dirty_fields (resolved live vs saved) and raw dirty state.

Author: trissim

docs/state_management.rst

@@ -29,13 +29,23 @@ Saved vs Live
 - ``_live_resolved`` represents "on screen" (after every edit and ancestor change).
 - ``mark_saved()`` updates saved baselines from current live values.
 - ``restore_saved()`` resets working values back to the saved snapshot.
-- ``is_dirty()`` compares current parameters to ``_saved_parameters`` to detect unsaved work.
+- ``dirty_fields`` tracks where ``_live_resolved`` differs from ``_saved_resolved`` (resolved / inherited view).
+- ``is_raw_dirty`` is a fast check for unsaved edits in raw parameters (``parameters`` vs ``_saved_parameters``).
+
+Reading resolved values
+~~~~~~~~~~~~~~~~~~~~~~
+ObjectState keeps both a *live* resolved snapshot and a *saved* resolved snapshot.
+Use the appropriate accessor depending on whether you want to include unsaved edits:
+
+- ``get_resolved_value(name)``: returns the live resolved value from ``_live_resolved`` (includes unsaved edits)
+- ``get_saved_resolved_value(name)``: returns the saved resolved value from ``_saved_resolved`` (excludes unsaved edits)
 
 Key methods
 ~~~~~~~~~~~
 - ``mark_saved()``: set current state as the new baseline
 - ``restore_saved()``: revert parameters/resolved values to saved baseline
-- ``is_dirty()``: true if parameters differ from saved parameters
+- ``dirty_fields``: resolved diffs (live vs saved) as a set of dotted field names
+- ``is_raw_dirty``: true if raw parameters differ from saved parameters
 - ``to_object()``: materialize a concrete object from the current parameters
 
 Lifecycle

src/objectstate/object_state.py

@@ -2167,6 +2167,23 @@ def get_resolved_value(self, param_name: str) -> Any:
 
         return result
 
+    def get_saved_resolved_value(self, param_name: str) -> Any:
+        """Get saved resolved value for a field from the saved snapshot.
+
+        Unlike get_resolved_value() which returns live values (including unsaved edits),
+        this returns the saved baseline with inheritance applied. This is useful for
+        compilation and other operations that should only consider saved state.
+
+        Args:
+            param_name: Field name to resolve (can be dotted path like 'path_planning_config.well_filter')
+
+        Returns:
+            Saved resolved value from _saved_resolved snapshot
+        """
+        # Auto-detect delegate changes before resolving values
+        self._check_and_sync_delegate()
+        return self._saved_resolved.get(param_name)
+
     def get_provenance(self, param_name: str) -> Optional[Tuple[str, type]]:
         """Get the source scope_id and type for an inherited field value.
 
@@ -2504,6 +2521,11 @@ def signature_diff_fields(self) -> Set[str]:
         """Fields where raw != signature_default."""
         return self._signature_diff_fields
 
+    @property
+    def is_raw_dirty(self) -> bool:
+        """Check if raw parameters differ from saved parameters (not resolved values)."""
+        return self.parameters != self._saved_parameters
+
     def _compute_dirty_fields(self) -> Set[str]:
         """Compute dirty set from live vs saved caches."""
         if self._live_resolved is None: