experimaestro 1.11.1__py3-none-any.whl → 2.0.0b4__py3-none-any.whl

experimaestro/core/objects/config.py

@@ -9,7 +9,6 @@ from experimaestro import taskglobals
 
 from termcolor import cprint
 from pathlib import Path
-import hashlib
 import logging
 import io
 from enum import Enum
@@ -20,12 +19,10 @@ from typing import (
     Callable,
     ClassVar,
     Dict,
-    Iterator,
     List,
     Optional,
     Set,
     Tuple,
-    Type,
     TypeVar,
     Union,
     overload,
@@ -33,13 +30,14 @@ from typing import (
 )
 import sys
 import experimaestro
-from experimaestro.utils import logger
+from experimaestro.utils import logger, get_caller_location
 from experimaestro.core.types import DeprecatedAttribute, ObjectType, TypeVarType
 from ..context import SerializationContext, SerializedPath, SerializedPathLoader
 
 if TYPE_CHECKING:
     from ..callbacks import TaskEventListener
     from ..identifier import Identifier
+    from ..subparameters import Subparameters
     from experimaestro.scheduler.base import Job
     from experimaestro.scheduler.workspace import RunMode
     from experimaestro.launchers import Launcher
@@ -49,7 +47,6 @@ from .config_walk import ConfigWalk, ConfigWalkContext
 from .config_utils import (
     getqualattr,
     add_to_path,
-    SealedError,
     TaggedValue,
     ObjectStore,
     classproperty,
@@ -59,6 +56,26 @@ T = TypeVar("T", bound="Config")
 
 
 DependentMarker = Callable[["Config"], None]
+"""Type alias for dependency marker functions.
+
+A DependentMarker is a callable that marks a configuration as a dependency
+of another configuration. Used in ``task_outputs()`` and dynamic output methods
+to establish task dependencies.
+
+Example::
+
+    class Learn(Task):
+        model: Param[Model]
+
+        def task_outputs(self, dep: DependentMarker):
+            return dep(Checkpoint.C(model=self.model, path=self.checkpoint_path))
+
+    class Validation(Config):
+        model: Param[Model]
+
+        def checkpoint(self, dep: DependentMarker, *, step: int) -> Checkpoint:
+            return dep(Checkpoint.C(model=self.model, step=step))
+"""
 
 
 def updatedependencies(
@@ -94,9 +111,6 @@ NOT_SET = object()
 
 @define()
 class WatchedOutput:
-    #: The enclosing job
-    job: "Job"
-
     #: The configuration containing the watched output
     config: "ConfigInformation"
 
@@ -109,6 +123,61 @@ class WatchedOutput:
     #: The callback to call (with the output of the previous method)
     callback: Callable
 
+    #: The enclosing job (set when registered with scheduler)
+    job: Optional["Job"] = None
+
+
+def get_generated_paths(
+    v: Union["ConfigMixin", list, dict],
+    path: list[str] | None = None,
+    paths: list[str] | None = None,
+) -> list[str]:
+    """Get the list of generated paths, useful to track down those
+
+    :param path: The current path
+    :param paths: The list of generated paths so far, defaults to None
+    :return: The full list of generated paths
+    """
+    paths = [] if paths is None else paths
+    path = [] if path is None else path
+
+    if isinstance(v, list):
+        for ix, element in enumerate(v):
+            get_generated_paths(element, path + [f"[{ix}]"], paths)
+
+    elif isinstance(v, dict):
+        for key, element in v.items():
+            get_generated_paths(element, path + [f"[{key}]"], paths)
+
+    elif isinstance(v, ConfigMixin):
+        for key in v.__xpm__._generated_values:
+            value = v.__xpm__.values[key]
+            if isinstance(value, ConfigMixin) and value.__xpm__._generated_values:
+                path.append(key)
+                get_generated_paths(value, path, paths)
+                path.pop()
+            else:
+                paths.append(".".join(path + [key]))
+    else:
+        raise ValueError(f"Cannot handle type {type(v)}")
+    return paths
+
+
+@define
+class TaskStub:
+    """Stub for a task that was not loaded during partial loading.
+
+    This is used when loading configurations from disk (e.g., HuggingFace)
+    where the task code may have changed or is not available. The stub stores
+    the identifier and typename so the information is preserved.
+    """
+
+    identifier: "Identifier"
+    """The experimaestro identifier of the task"""
+
+    typename: str
+    """The type name of the task (e.g., 'mymodule.MyTask')"""
+
 
 class ConfigInformation:
     """Holds experimaestro information for a config (or task) instance"""
@@ -122,11 +191,13 @@ class ConfigInformation:
     def __init__(self, pyobject: "ConfigMixin"):
         # The underlying pyobject and XPM type
         self.pyobject = pyobject
-        self.xpmtype = pyobject.__xpmtype__  # type: ObjectType
+        self.xpmtype: "ObjectType" = pyobject.__xpmtype__
         self.values = {}
 
         # Meta-informations
-        self._tags = {}
+        # Tags are stored as {name: (value, source_location)}
+        # where source_location is "file:line" string for error reporting
+        self._tags: dict[str, tuple[Any, str]] = {}
         self._initinfo = ""
 
         self._taskoutput = None
@@ -142,16 +213,13 @@ class ConfigInformation:
         #: True when this configuration was loaded from disk
         self.loaded = False
 
-        # Explicitely added dependencies
+        # Explicitly added dependencies
         self.dependencies = []
 
         # Concrete type variables resolutions
         # This is used to check typevars coherence
         self.concrete_typevars: Dict[TypeVar, type] = {}
 
-        # Lightweight tasks
-        self.pre_tasks: List["LightweightTask"] = []
-
         # Initialization tasks
         self.init_tasks: List["LightweightTask"] = []
 
@@ -160,16 +228,21 @@ class ConfigInformation:
 
         # Cached information
 
-        self._full_identifier = None
-        """The full identifier (with pre-tasks)"""
+        self._identifier = None
+        """The configuration identifier (cached when sealed)"""
 
-        self._raw_identifier = None
-        """The identifier without taking into account pre-tasks"""
+        self._partial_identifiers: Dict[str, "Identifier"] = {}
+        """Cached partial identifiers (keyed by subparameters name)"""
 
         self._validated = False
         self._sealed = False
         self._meta = None
 
+        # This contains the list of generated values (using context) in this
+        # configuration or any sub-configuration, is generated. This prevents
+        # problem when a configuration with generated values is re-used.
+        self._generated_values = []
+
     def set_meta(self, value: Optional[bool]):
         """Sets the meta flag"""
         assert not self._sealed, "Configuration is sealed"
@@ -187,6 +260,31 @@ class ConfigInformation:
         # Not an argument, bypass
         return object.__getattribute__(self.pyobject, name)
 
+    @staticmethod
+    def is_generated_value(argument, value):
+        if argument.ignore_generated:
+            return False
+
+        if value is None:
+            return False
+
+        if isinstance(value, (int, str, float, bool, Enum, Path)):
+            return False
+
+        if isinstance(value, ConfigMixin):
+            return value.__xpm__._generated_values and value.__xpm__.task is None
+
+        if isinstance(value, list):
+            return any(ConfigInformation.is_generated_value(argument, x) for x in value)
+
+        if isinstance(value, dict):
+            return any(
+                ConfigInformation.is_generated_value(argument, x)
+                for x in value.values()
+            )
+
+        return False
+
     def set(self, k, v, bypass=False):
         from experimaestro.generators import Generator
 
@@ -198,9 +296,21 @@ class ConfigInformation:
         if self._sealed and not bypass:
             raise AttributeError(f"Object is read-only (trying to set {k})")
 
+        if not isinstance(v, ConfigMixin) and isinstance(v, Config):
+            raise AttributeError(
+                "Configuration (and not objects) should be used. Consider using .C(...)"
+            )
+
         try:
             argument = self.xpmtype.arguments.get(k, None)
             if argument:
+                if ConfigInformation.is_generated_value(argument, v):
+                    raise AttributeError(
+                        f"Cannot set {k} to a configuration with generated values. "
+                        "Here is the list of paths to help you: "
+                        f"""{', '.join(get_generated_paths(v, [k]))}"""
+                    )
+
                 if not bypass and (
                     (isinstance(argument.generator, Generator)) or argument.constant
                 ):
@@ -263,8 +373,17 @@ class ConfigInformation:
             f" (current typevars bindings: {self.concrete_typevars})"
         )
 
-    def addtag(self, name, value):
-        self._tags[name] = value
+    def addtag(self, name, value, source: str = None):
+        """Add a tag with optional source location for error reporting
+
+        Args:
+            name: Tag name
+            value: Tag value
+            source: Source location string (file:line). If None, captured from caller.
+        """
+        if source is None:
+            source = get_caller_location(skip_frames=1)
+        self._tags[name] = (value, source)
 
     def xpmvalues(self, generated=False):
         """Returns an iterarator over arguments and associated values"""
@@ -276,11 +395,29 @@ class ConfigInformation:
         class TagFinder(ConfigWalk):
             def __init__(self):
                 super().__init__(recurse_task=True)
-                self.tags = {}
+                # Store {name: (value, source)} for conflict detection
+                self.tags_with_source: dict[str, tuple[Any, str]] = {}
 
             def postprocess(self, stub, config: Config, values):
-                self.tags.update(config.__xpm__._tags)
-                return self.tags
+                for name, (value, source) in config.__xpm__._tags.items():
+                    if name in self.tags_with_source:
+                        existing_value, existing_source = self.tags_with_source[name]
+                        if existing_value != value:
+                            logger.warning(
+                                "Tag '%s' has conflicting values: "
+                                "'%s' (set at %s) vs '%s' (set at %s). "
+                                "Using the latter value.",
+                                name,
+                                existing_value,
+                                existing_source,
+                                value,
+                                source,
+                            )
+                    self.tags_with_source[name] = (value, source)
+                # Return just the values (without source info)
+                return {
+                    name: value for name, (value, _) in self.tags_with_source.items()
+                }
 
         return TagFinder()(self.pyobject)
 
@@ -302,10 +439,6 @@ class ConfigInformation:
                             % (k, self.xpmtype, self._initinfo)
                         )
 
-            # Validate pre-tasks
-            for pre_task in self.pre_tasks:
-                pre_task.__xpm__.validate()
-
             # Validate init tasks
             for init_task in self.init_tasks:
                 init_task.__xpm__.validate()
@@ -326,12 +459,21 @@ class ConfigInformation:
         Arguments:
             - context: the generation context
         """
+        if generated_keys := [
+            k
+            for k, v in self.values.items()
+            if ConfigInformation.is_generated_value(self.xpmtype.arguments[k], v)
+        ]:
+            raise AttributeError(
+                "Cannot seal a configuration with generated values:"
+                f"""{",".join(generated_keys)} in {context.currentpath}"""
+            )
 
         class Sealer(ConfigWalk):
-            def preprocess(self, config: Config):
+            def preprocess(self, config: ConfigMixin):
                 return not config.__xpm__._sealed, config
 
-            def postprocess(self, stub, config: Config, values):
+            def postprocess(self, stub, config: ConfigMixin, values):
                 # Generate values
                 from experimaestro.generators import Generator
 
@@ -344,22 +486,42 @@ class ConfigInformation:
                                     continue
                                 value = argument.generator()
                             else:
+                                # Generate a value
                                 sig = inspect.signature(argument.generator)
                                 if len(sig.parameters) == 0:
                                     value = argument.generator()
                                 elif len(sig.parameters) == 2:
+                                    # Only in that case do we need to flag this configuration
+                                    # as containing generated values
+                                    if not argument.ignore_generated:
+                                        config.__xpm__._generated_values.append(k)
+                                    else:
+                                        logging.warning("Ignoring %s", k)
                                     value = argument.generator(self.context, config)
                                 else:
                                     assert (
                                         False
                                     ), "generator has either two parameters (context and config), or none"
                             config.__xpm__.set(k, value, bypass=True)
+                        else:
+                            value = config.__xpm__.values.get(k)
                     except Exception:
                         logger.error(
                             "While setting %s of %s", argument.name, config.__xpmtype__
                         )
                         raise
 
+                    # Propagate the generated value flag
+                    if (
+                        value is not None
+                        and isinstance(value, ConfigMixin)
+                        and value.__xpm__._generated_values
+                    ):
+                        if not argument.ignore_generated:
+                            config.__xpm__._generated_values.append(k)
+                        else:
+                            logging.warning("Ignoring %s", k)
+
                 config.__xpm__._sealed = True
 
         Sealer(context, recurse_task=True)(self.pyobject)
@@ -372,90 +534,56 @@ class ConfigInformation:
         context = ConfigWalkContext()
 
         class Unsealer(ConfigWalk):
-            def preprocess(self, config: Config):
+            def preprocess(self, config: ConfigMixin):
                 return config.__xpm__._sealed, config
 
-            def postprocess(self, stub, config: Config, values):
+            def postprocess(self, stub, config: ConfigMixin, values):
                 config.__xpm__._sealed = False
                 config.__xpm__._identifier = None
 
         Unsealer(context, recurse_task=True)(self.pyobject)
 
-    def collect_pre_tasks(self) -> Iterator["Config"]:
-        context = ConfigWalkContext()
-        pre_tasks: Dict[int, "Config"] = {}
-
-        class PreTaskCollect(ConfigWalk):
-            def preprocess(self, config: Config):
-                # Do not cross tasks
-                return not isinstance(config.__xpm__, Task), config
-
-            def postprocess(self, stub, config: Config, values):
-                pre_tasks.update(
-                    {id(pre_task): pre_task for pre_task in config.__xpm__.pre_tasks}
-                )
-
-        PreTaskCollect(context, recurse_task=True)(self.pyobject)
-        return pre_tasks.values()
-
-    def identifiers(self, only_raw: bool):
+    @property
+    def identifier(self):
         """Computes the unique identifier"""
-        from ..identifier import IdentifierComputer, Identifier
-
-        raw_identifier = self._raw_identifier
-        full_identifier = self._full_identifier
+        from ..identifier import IdentifierComputer
 
         # Computes raw identifier if needed
-        if raw_identifier is None or not self._sealed:
-            # Get the main identifier
-            raw_identifier = IdentifierComputer.compute(self.pyobject)
-            if self._sealed:
-                self._raw_identifier = raw_identifier
-
-        if only_raw:
-            return raw_identifier, full_identifier
-
-        # OK, let's compute the full identifier
-        if full_identifier is None or not self._sealed:
-            # Compute the full identifier by including the pre-tasks
-            hasher = hashlib.sha256()
-            hasher.update(raw_identifier.all)
-            pre_tasks_ids = [
-                pre_task.__xpm__.raw_identifier.all
-                for pre_task in self.collect_pre_tasks()
-            ]
-            for task_id in sorted(pre_tasks_ids):
-                hasher.update(task_id)
+        if self._identifier is not None:
+            return self._identifier
 
-            # Adds init tasks
-            if self.init_tasks:
-                hasher.update(IdentifierComputer.INIT_TASKS)
-                for init_task in self.init_tasks:
-                    hasher.update(init_task.__xpm__.raw_identifier.all)
+        # Get the main identifier
+        identifier = IdentifierComputer.compute(self.pyobject)
+        if self._sealed:
+            self._identifier = identifier
+        return identifier
 
-            full_identifier = Identifier(hasher.digest())
-            full_identifier.has_loops = raw_identifier.has_loops
+    def get_partial_identifier(self, subparameters: "Subparameters") -> "Identifier":
+        """Get the partial identifier for a given subparameters instance.
 
-            # Only cache the identifier if sealed
-            if self._sealed:
-                self._full_identifier = full_identifier
+        Partial identifiers exclude certain parameter groups, allowing
+        configurations that differ only in those groups to share the same
+        partial identifier (and thus the same partial directory).
 
-        return raw_identifier, full_identifier
+        Args:
+            subparameters: The Subparameters instance defining which groups
+                to include/exclude.
 
-    @property
-    def raw_identifier(self) -> "Identifier":
-        """Computes the unique identifier (without task modifiers)"""
-        raw_identifier, _ = self.identifiers(True)
-        return raw_identifier
+        Returns:
+            The partial identifier for this configuration.
+        """
+        from ..identifier import IdentifierComputer
 
-    @property
-    def full_identifier(self) -> "Identifier":
-        """Computes the unique identifier (with task modifiers)"""
-        _, full_identifier = self.identifiers(False)
-        return full_identifier
+        name = subparameters.name
+        if name in self._partial_identifiers:
+            return self._partial_identifiers[name]
+
+        identifier = IdentifierComputer.compute_partial(self.pyobject, subparameters)
+
+        if self._sealed:
+            self._partial_identifiers[name] = identifier
 
-    identifier = full_identifier
-    """Deprecated: use full_identifier"""
+        return identifier
 
     def dependency(self):
         """Returns a dependency"""
@@ -470,12 +598,6 @@ class ConfigInformation:
         path: List[str],
         taskids: Set[int],
     ):
-        # Add pre-tasks
-        for pre_task in self.pre_tasks:
-            pre_task.__xpm__.updatedependencies(
-                dependencies, path + ["__pre_tasks__"], taskids
-            )
-
         # Add initialization tasks
         for init_task in self.init_tasks:
             init_task.__xpm__.updatedependencies(
@@ -537,10 +659,20 @@ class ConfigInformation:
 
         :param method: The method to watch
         :param callback: The callback
+
+        :raises TypeError: If the task is not a ResumableTask
         """
-        watched = WatchedOutput(
-            self, method.__self__, method.__name__, method, callback
-        )
+        # Only ResumableTask can have dynamic outputs - regular tasks
+        # have their directories cleaned up, losing the output file
+        if not isinstance(self.pyobject, ResumableTask):
+            raise TypeError(
+                f"Only ResumableTask can use watch_output. "
+                f"{self.xpmtype} is not a ResumableTask. "
+                "Dynamic outputs require the task directory to be preserved "
+                "across restarts, which only ResumableTask provides."
+            )
+
+        watched = WatchedOutput(method.__self__, method.__name__, method, callback)
         self.watched_outputs.append(watched)
         if self.job:
             self.job.watch_output(watched)
@@ -561,6 +693,7 @@ class ConfigInformation:
         *,
         run_mode=None,
         init_tasks: List["LightweightTask"] = [],
+        max_retries: Optional[int] = None,
     ):
         from experimaestro.scheduler import experiment, JobContext
         from experimaestro.scheduler.workspace import RunMode
@@ -580,7 +713,11 @@ class ConfigInformation:
 
         # Creates a new job
         self.job = self.xpmtype.task(
-            self.pyobject, launcher=launcher, workspace=workspace, run_mode=run_mode
+            self.pyobject,
+            launcher=launcher,
+            workspace=workspace,
+            run_mode=run_mode,
+            max_retries=max_retries,
         )
 
         # Validate the object
@@ -620,8 +757,8 @@ class ConfigInformation:
             TaskEventListener.connect(experiment.CURRENT)
             other = experiment.CURRENT.submit(self.job)
             if other:
-                # Just returns the other task
-                return other.config.__xpm__._taskoutput
+                # Our job = previously submitted job
+                self.job = other
         else:
             # Show a warning
             if run_mode == RunMode.GENERATE_ONLY:
@@ -657,13 +794,6 @@ class ConfigInformation:
 
                 print(file=sys.stderr)  # noqa: T201
 
-        # Handle an output configuration # FIXME: remove
-        def mark_output(config: "Config"):
-            """Sets a dependency on the job"""
-            assert not isinstance(config, Task), "Cannot set a dependency on a task"
-            config.__xpm__.task = self.pyobject
-            return config
-
         # Mark this configuration also
         self.task = self.pyobject
 
@@ -677,6 +807,9 @@ class ConfigInformation:
     def mark_output(self, config: "Config"):
         """Sets a dependency on the job"""
         assert not isinstance(config, Task), "Cannot set a dependency on a task"
+        assert isinstance(
+            config, ConfigMixin
+        ), "Only configurations can be marked as dependent on a task"
         config.__xpm__.task = self.pyobject
         return config
 
@@ -752,9 +885,6 @@ class ConfigInformation:
         if self.task is not None and self.task is not self:
             ConfigInformation.__collect_objects__(self.task, objects, context)
 
-        # Serialize pre-tasks
-        ConfigInformation.__collect_objects__(self.pre_tasks, objects, context)
-
         # Serialize initialization tasks
         ConfigInformation.__collect_objects__(self.init_tasks, objects, context)
 
@@ -762,14 +892,12 @@ class ConfigInformation:
         state_dict = {
             "id": id(self.pyobject),
             "module": self.xpmtype._module,
-            "type": self.xpmtype.basetype.__qualname__,
+            "type": self.xpmtype.value_type.__qualname__,
             "typename": self.xpmtype.name(),
             "identifier": self.identifier.state_dict(),
         }
 
         # Add pre/init tasks
-        if self.pre_tasks:
-            state_dict["pre-tasks"] = [id(pre_task) for pre_task in self.pre_tasks]
         if self.init_tasks:
             state_dict["init-tasks"] = [id(init_task) for init_task in self.init_tasks]
 
@@ -826,7 +954,6 @@ class ConfigInformation:
 
         The format is an array of objects
         {
-            "tags: [ LIST_OF_TAGS ],
             "workspace": FOLDERPATH,
             "version": 2,
             "objects": [
@@ -846,6 +973,10 @@ class ConfigInformation:
 
         The last object is the one that is serialized
 
+        Note: Tags are no longer stored in params.json. They are managed by the
+        experiment state provider (scoped to job_id, experiment_id, run_id) and
+        also stored in experiment state.json for full experiment details.
+
         Arguments:
             out {io.TextIOBase} -- The output stream
             context {[type]} -- the command context
@@ -853,8 +984,8 @@ class ConfigInformation:
         json.dump(
             {
                 "workspace": str(context.workspace.path.absolute()),
-                "tags": {key: value for key, value in self.tags().items()},
                 "version": 2,
+                "experimaestro": experimaestro.__version__,
                 "objects": self.__get_objects__([], context),
             },
             out,
@@ -877,12 +1008,18 @@ class ConfigInformation:
         path: Union[str, Path, SerializedPathLoader],
         as_instance: bool = False,
         return_tasks: bool = False,
+        partial_loading: Optional[bool] = None,
     ) -> "Config":
         """Deserialize a configuration
 
         :param path: The filesystem Path to use, or a way to download the
             information through a function taking two arguments
         :param as_instance: Return an instance
+        :param return_tasks: Return init tasks instead of executing them
+        :param partial_loading: If True, skip loading task references. If None
+            (default), partial_loading is enabled when as_instance is True.
+            This is useful when loading configurations from disk (e.g.,
+            HuggingFace) where the task code may have changed.
         :return: a Config object, its instance or a tuple (instance, init_tasks) is return_tasks is True
         """
         # Load
@@ -907,6 +1044,7 @@ class ConfigInformation:
             as_instance=as_instance,
             data_loader=data_loader,
             return_tasks=return_tasks,
+            partial_loading=partial_loading,
         )
 
     @staticmethod
@@ -949,34 +1087,97 @@ class ConfigInformation:
 
     @overload
     @staticmethod
-    def fromParameters(
+    def fromParameters(  # noqa: E704
         definitions: List[Dict],
         as_instance=True,
         save_directory: Optional[Path] = None,
         discard_id: bool = False,
-    ) -> "ConfigMixin":
-        ...
+        partial_loading: Optional[bool] = None,
+    ) -> "ConfigMixin": ...
 
     @overload
     @staticmethod
-    def fromParameters(
+    def fromParameters(  # noqa: E704
         definitions: List[Dict],
         as_instance=False,
         return_tasks=True,
         save_directory: Optional[Path] = None,
         discard_id: bool = False,
-    ) -> Tuple["Config", List["LightweightTask"]]:
-        ...
+        partial_loading: Optional[bool] = None,
+    ) -> Tuple["Config", List["LightweightTask"]]: ...
 
     @overload
     @staticmethod
-    def fromParameters(
+    def fromParameters(  # noqa: E704
         definitions: List[Dict],
         as_instance=False,
         save_directory: Optional[Path] = None,
         discard_id: bool = False,
-    ) -> "Config":
-        ...
+        partial_loading: Optional[bool] = None,
+    ) -> "Config": ...
+
+    @staticmethod
+    def _get_field_refs(value: Any) -> Set[int]:
+        """Recursively extract object references from a serialized field value"""
+        refs: Set[int] = set()
+        if isinstance(value, dict):
+            if value.get("type") == "python":
+                refs.add(value["value"])
+            else:
+                for v in value.values():
+                    refs.update(ConfigInformation._get_field_refs(v))
+        elif isinstance(value, list):
+            for v in value:
+                refs.update(ConfigInformation._get_field_refs(v))
+        return refs
+
+    @staticmethod
+    def _compute_skipped_ids(definitions: List[Dict]) -> Set[int]:
+        """Compute IDs of objects only reachable through task references.
+
+        When partial_loading is enabled, we skip loading task references and
+        any objects that are only used by those tasks. This method computes
+        which object IDs should be skipped by finding objects reachable from
+        the main object (last definition) without following task references.
+
+        :param definitions: List of object definitions from JSON
+        :return: Set of object IDs to skip loading
+        """
+        # Build index of definitions by ID
+        def_by_id = {d["id"]: d for d in definitions}
+
+        # Compute reachable objects from main object (last definition)
+        # without going through task references
+        main_defn = definitions[-1]
+        main_id = main_defn["id"]
+        reachable: Set[int] = set()
+        to_visit = [main_id]
+
+        # Also include init-tasks as reachable (needed for as_instance/return_tasks)
+        for init_task_id in main_defn.get("init-tasks", []):
+            to_visit.append(init_task_id)
+
+        while to_visit:
+            obj_id = to_visit.pop()
+            if obj_id in reachable:
+                continue
+            reachable.add(obj_id)
+
+            defn = def_by_id.get(obj_id)
+            if defn is None:
+                continue
+
+            # Add field references (not task reference)
+            for field_value in defn.get("fields", {}).values():
+                for ref_id in ConfigInformation._get_field_refs(field_value):
+                    if ref_id not in reachable:
+                        to_visit.append(ref_id)
+
+            # Note: we intentionally skip defn["task"] to avoid loading tasks
+
+        # All objects not reachable should be skipped
+        all_ids = {d["id"] for d in definitions}
+        return all_ids - reachable
 
     @staticmethod
     def load_objects(  # noqa: C901
@@ -984,15 +1185,43 @@ class ConfigInformation:
         as_instance=True,
         data_loader: Optional[SerializedPathLoader] = None,
         discard_id: bool = False,
+        partial_loading: bool = False,
     ):
-        """Load the objects"""
+        """Load the objects
+
+        :param definitions: List of object definitions from JSON
+        :param as_instance: Return instances instead of configs
+        :param data_loader: Function to load data files
+        :param discard_id: If True, don't use the stored identifier
+        :param partial_loading: If True, skip loading task references. This is
+            useful when loading configurations from disk (e.g., HuggingFace)
+            where the task code may have changed.
+        """
         o = None
         objects = {}
         import experimaestro.taskglobals as taskglobals
         from ..identifier import Identifier
 
+        # Compute which objects to skip when partial_loading
+        skipped_ids = (
+            ConfigInformation._compute_skipped_ids(definitions)
+            if partial_loading
+            else set()
+        )
+
         # Loop over all the definitions and create objects
         for definition in definitions:
+            obj_id = definition["id"]
+
+            # Skip objects that are only reachable through task references
+            if obj_id in skipped_ids:
+                # Create a TaskStub for skipped task objects
+                objects[obj_id] = TaskStub(
+                    identifier=Identifier.from_state_dict(definition["identifier"]),
+                    typename=definition.get("typename", definition["type"]),
+                )
+                continue
+
             module_name = definition["module"]
 
             # Avoids problem when runing module
@@ -1022,15 +1251,21 @@ class ConfigInformation:
 
             # Creates an object (or a config)
             if as_instance:
-                o = cls.XPMValue.__new__(cls.XPMValue)
+                o = cls.__new__(cls)
             else:
                 o = cls.XPMConfig.__new__(cls.XPMConfig)
-            assert definition["id"] not in objects, "Duplicate id %s" % definition["id"]
-            objects[definition["id"]] = o
+            assert obj_id not in objects, "Duplicate id %s" % obj_id
+            objects[obj_id] = o
 
         # Now that objects have been created, fill in the fields
         for definition in definitions:
-            o = objects[definition["id"]]
+            obj_id = definition["id"]
+
+            # Skip processing skipped objects (they are TaskStubs)
+            if obj_id in skipped_ids:
+                continue
+
+            o = objects[obj_id]
             xpmtype = o.__getxpmtype__()  # type: ObjectType
 
             # If instance...
@@ -1101,12 +1336,6 @@ class ConfigInformation:
                 o.__post_init__()
 
             else:
-                # Sets pre-tasks
-                o.__xpm__.pre_tasks = [
-                    objects[pre_task_id]
-                    for pre_task_id in definition.get("pre-tasks", [])
-                ]
-
                 if task_id := definition.get("task", None):
                     o.__xpm__.task = objects[task_id]
 
@@ -1126,13 +1355,20 @@ class ConfigInformation:
         data_loader: Optional[SerializedPathLoader] = None,
         discard_id: bool = False,
         return_tasks: bool = False,
+        partial_loading: Optional[bool] = None,
     ):
+        # Determine effective partial_loading: as_instance implies partial_loading
+        effective_partial_loading = (
+            partial_loading if partial_loading is not None else as_instance
+        )
+
         # Get the objects
         objects = ConfigInformation.load_objects(
             definitions,
             as_instance=as_instance,
             data_loader=data_loader,
             discard_id=discard_id,
+            partial_loading=effective_partial_loading,
         )
 
         # Get the last one
@@ -1140,15 +1376,6 @@ class ConfigInformation:
 
         # Run pre-task (or returns them)
         if as_instance or return_tasks:
-            # Collect pre-tasks (just once)
-            completed_pretasks = set()
-            pre_tasks = []
-            for definition in definitions:
-                for pre_task_id in definition.get("pre-tasks", []):
-                    if pre_task_id not in completed_pretasks:
-                        completed_pretasks.add(pre_task_id)
-                        pre_tasks.append(objects[pre_task_id])
-
             # Collect init tasks
             init_tasks = []
             for init_task_id in definitions[-1].get("init-tasks", []):
@@ -1156,14 +1383,11 @@ class ConfigInformation:
                 init_tasks.append(init_task)
 
             if as_instance:
-                for pre_task in pre_tasks:
-                    logger.info("Executing pre-task %s", type(pre_task))
-                    pre_task.execute()
                 for init_task in init_tasks:
                     logger.info("Executing init task %s", type(init_task))
                     init_task.execute()
             else:
-                return o, pre_tasks, pre_task + init_tasks
+                return o, init_tasks
 
         return o
 
@@ -1171,7 +1395,6 @@ class ConfigInformation:
         def __init__(self, context: ConfigWalkContext, *, objects: ObjectStore = None):
             super().__init__(context)
             self.objects = ObjectStore() if objects is None else objects
-            self.pre_tasks = {}
 
         def preprocess(self, config: "Config"):
             if self.objects.is_constructed(id(config)):
@@ -1183,7 +1406,7 @@ class ConfigInformation:
 
             if o is None:
                 # Creates an object (and not a config)
-                o = config.XPMValue()
+                o = config.__xpmtype__.value_type()
 
                 # Store in cache
                 self.objects.add_stub(id(config), o)
@@ -1198,10 +1421,6 @@ class ConfigInformation:
             # Call __post_init__
             stub.__post_init__()
 
-            # Gather pre-tasks
-            for pre_task in config.__xpm__.pre_tasks:
-                self.pre_tasks[id(pre_task)] = self.stub(pre_task)
-
             self.objects.set_constructed(id(config))
             return stub
 
@@ -1215,10 +1434,6 @@ class ConfigInformation:
         processor = ConfigInformation.FromPython(context, objects=objects)
         last_object = processor(self.pyobject)
 
-        # Execute pre-tasks
-        for pre_task in processor.pre_tasks.values():
-            pre_task.execute()
-
         return last_object
 
     def add_dependencies(self, *dependencies):
@@ -1242,6 +1457,9 @@ def clone(v):
     if isinstance(v, Enum):
         return v
 
+    if isinstance(v, tuple):
+        return tuple(clone(x) for x in v)
+
     if isinstance(v, Config):
         # Create a new instance
         kwargs = {
@@ -1260,10 +1478,104 @@ class ConfigMixin:
     """Class for configuration objects"""
 
     __xpmtype__: ObjectType
+    """The associated XPM type"""
+
+    __xpm__: ConfigInformation
+    """The __xpm__ object contains all instance specific information about a
+    configuration/task"""
+
+    # Set when this instance was created via a deprecated config with replace=True
+    _deprecated_from: "ConfigMixin | None" = None
+
+    def __new__(cls, **kwargs):
+        """Create a new config instance, handling deprecated replacements."""
+        xpmtype = cls.__xpmtype__
+
+        # Check if this is a deprecated type with replace=True
+        if xpmtype._deprecation is not None and xpmtype._deprecation.replace:
+            # Create the deprecated instance normally
+            instance = object.__new__(cls)
+            # Initialize it
+            ConfigMixin.__init__(instance, **kwargs)
+            # Convert to the new type
+            converted = instance.__convert__()
+            # Mark that this came from a deprecated config
+            converted._deprecated_from = instance
+            return converted
+
+        # Normal creation
+        return object.__new__(cls)
+
+    def __getattribute__(self, name: str):
+        """Get an attribute, handling XPM arguments specially.
+
+        We use __getattribute__ instead of __getattr__ because default values
+        like `b: Param[X] = None` create class attributes that would prevent
+        __getattr__ from being called.
+        """
+        # Get __xpm__ without recursion
+        try:
+            xpm = object.__getattribute__(self, "__xpm__")
+        except AttributeError:
+            # During early init, __xpm__ may not exist yet
+            return object.__getattribute__(self, name)
+
+        # Check if this is an XPM argument - parameters take precedence
+        xpmtype = object.__getattribute__(self, "__xpmtype__")
+        if name in xpmtype.arguments:
+            return xpm.get(name)
+
+        # Fall back to normal lookup (methods, etc.)
+        return object.__getattribute__(self, name)
+
+    def __setattr__(self, name: str, value):
+        """Set an attribute, handling XPM arguments specially."""
+        # Allow setting internal attributes directly
+        if name in ("__xpm__", "_deprecated_from"):
+            object.__setattr__(self, name, value)
+            return
+
+        # Check if we have __xpm__ yet (might not during early init)
+        xpm = self.__dict__.get("__xpm__")
+        if xpm is None:
+            object.__setattr__(self, name, value)
+            return
+
+        # Check if this is an XPM argument
+        xpmtype = self.__xpmtype__
+        if name in xpmtype.arguments:
+            # Handle TaggedValue: extract value and add tag
+            if isinstance(value, TaggedValue):
+                actual_value = value.value
+                source = get_caller_location(skip_frames=1)
+                xpm.addtag(name, actual_value, source=source)
+                xpm.set(name, actual_value)
+            else:
+                xpm.set(name, value)
+            return
+
+        # Check for deprecated replacement warning
+        deprecated_from = self.__dict__.get("_deprecated_from")
+        if deprecated_from is not None:
+            deprecated_xpmtype = deprecated_from.__xpmtype__
+            if name in deprecated_xpmtype.arguments:
+                logger.warning(
+                    f"Attribute '{name}' was in deprecated config "
+                    f"{deprecated_xpmtype.identifier} but is not in "
+                    f"{xpmtype.identifier}. The value is being discarded."
+                )
+                return  # Don't set the attribute
+
+        # Normal attribute setting
+        object.__setattr__(self, name, value)
 
     def __init__(self, **kwargs):
         """Initialize the configuration with the given parameters"""
 
+        # Skip if already initialized (can happen with deprecated replace=True)
+        if hasattr(self, "__xpm__"):
+            return
+
         # Add configuration
         xpmtype = self.__xpmtype__
 
@@ -1297,7 +1609,8 @@ class ConfigMixin:
             # Special case of a tagged value
             if isinstance(value, TaggedValue):
                 value = value.value
-                self.__xpm__._tags[name] = value
+                # Use _initinfo as source since tag is set at config creation
+                self.__xpm__.addtag(name, value, source=xpm._initinfo)
 
             # Really set the value
             xpm.set(name, value)
@@ -1310,12 +1623,14 @@ class ConfigMixin:
             [f"{key}={value}" for key, value in self.__xpm__.values.items()]
         )
         return (
-            f"{self.__xpmtype__.basetype.__module__}."
-            f"{self.__xpmtype__.basetype.__qualname__}({params})"
+            f"{self.__xpmtype__.value_type.__module__}."
+            f"{self.__xpmtype__.value_type.__qualname__}({params})"
         )
 
     def tag(self, name, value):
-        self.__xpm__.addtag(name, value)
+        # Capture caller's location and pass to addtag
+        source = get_caller_location(skip_frames=1)
+        self.__xpm__.addtag(name, value, source=source)
         return self
 
     def __eq__(self, other):
@@ -1340,9 +1655,20 @@ class ConfigMixin:
         return self
 
     def instance(
-        self, context: ConfigWalkContext = None, *, objects: ObjectStore = None
+        self,
+        context: ConfigWalkContext = None,
+        *,
+        objects: ObjectStore = None,
+        keep: bool = True,
     ) -> T:
-        """Return an instance with the current values"""
+        """Return an instance with the current values
+
+        :param context: The context when computing the instance
+        :param objects: The previously built objects (so that we avoid
+            re-creating instances of past configurations)
+        :param keep: register a configuration in the __config__ field of the
+            instance
+        """
         if context is None:
             from experimaestro.xpmutils import EmptyContext
 
@@ -1351,7 +1677,11 @@ class ConfigMixin:
             assert isinstance(
                 context, ConfigWalkContext
             ), f"{context.__class__} is not an instance of ConfigWalkContext"
-        return self.__xpm__.fromConfig(context, objects=objects)  # type: ignore
+
+        instance = self.__xpm__.fromConfig(context, objects=objects)  # type: ignore
+        if keep:
+            object.__setattr__(instance, "__config__", self)
+        return instance
 
     def submit(
         self,
@@ -1360,16 +1690,22 @@ class ConfigMixin:
         launcher=None,
         run_mode: "RunMode" = None,
         init_tasks: List["LightweightTask"] = [],
+        max_retries: Optional[int] = None,
     ):
         """Submit this task
 
         :param workspace: the workspace, defaults to None
         :param launcher: The launcher, defaults to None
         :param run_mode: Run mode (if None, uses the workspace default)
+        :param max_retries: Maximum number of retries for resumable tasks that timeout (default: from workspace settings or 3)
         :return: an object object
         """
         return self.__xpm__.submit(
-            workspace, launcher, run_mode=run_mode, init_tasks=init_tasks
+            workspace,
+            launcher,
+            run_mode=run_mode,
+            init_tasks=init_tasks,
+            max_retries=max_retries,
         )
 
     def stdout(self):
@@ -1396,29 +1732,7 @@ class ConfigMixin:
         attributes)"""
         return clone(self)
 
-    def add_pretasks(self, *tasks: "LightweightTask"):
-        assert all(
-            [isinstance(task, LightweightTask) for task in tasks]
-        ), "One of the pre-tasks are not lightweight tasks"
-        if self.__xpm__._sealed:
-            raise SealedError("Cannot add pre-tasks to a sealed configuration")
-        self.__xpm__.pre_tasks.extend(tasks)
-        return self
-
-    def add_pretasks_from(self, *configs: "Config"):
-        assert all(
-            [isinstance(config, ConfigMixin) for config in configs]
-        ), "One of the parameters is not a configuration object"
-        for config in configs:
-            self.add_pretasks(*config.__xpm__.pre_tasks)
-        return self
-
-    @property
-    def pre_tasks(self) -> List["LightweightTask"]:
-        """Access pre-tasks"""
-        return self.__xpm__.pre_tasks
-
-    def copy_dependencies(self, other: "Config"):
+    def copy_dependencies(self, other: "ConfigMixin"):
         """Add all the dependencies from other configuration"""
 
         # Add task dependency
@@ -1429,6 +1743,59 @@ class ConfigMixin:
         # Add other dependencies
         self.__xpm__.add_dependencies(*other.__xpm__.dependencies)
 
+    def __rmatmul__(self, other: "ConfigMixin") -> "ConfigMixin":
+        """Right-associative composition operator: B() @ A(x=1) is equivalent to B(a=A(x=1))
+
+        For expression `other @ self`, finds the unique parameter in `other` that
+        accepts `self`'s type and sets it. Returns `self` to enable right-associative
+        chaining: `Outer() @ Middle() @ Inner()` builds Outer(middle=Middle(inner=Inner())).
+
+        The chain is evaluated left-to-right by Python, but returns the inner config
+        so each step adds the current result as a parameter to the next outer config.
+
+        :param other: The outer configuration that will receive self as a parameter
+        :return: self (the inner configuration) to continue the chain
+        """
+        if not isinstance(other, ConfigMixin):
+            return NotImplemented
+
+        # Find parameters in 'other' that can accept self's type
+        self_type = self.__xpmtype__.value_type
+        matching_params = []
+
+        for name, argument in other.__xpmtype__.arguments.items():
+            # Get the expected type for this argument
+            arg_type = argument.type
+            if hasattr(arg_type, "value_type"):
+                # It's an ObjectType wrapper
+                expected_type = arg_type.value_type
+            elif hasattr(arg_type, "__origin__"):
+                # Generic type like Optional[X] or List[X]
+                continue  # Skip complex types for now
+            elif isinstance(arg_type, type):
+                expected_type = arg_type
+            else:
+                continue
+
+            # Check if self's type is compatible
+            if isinstance(expected_type, type) and issubclass(self_type, expected_type):
+                matching_params.append(name)
+
+        if len(matching_params) == 0:
+            raise ValueError(
+                f"No parameter in {other.__xpmtype__} accepts type {self_type.__name__}"
+            )
+        if len(matching_params) > 1:
+            raise ValueError(
+                f"Ambiguous composition: parameters {matching_params} in "
+                f"{other.__xpmtype__} all accept type {self_type.__name__}"
+            )
+
+        # Set the parameter on 'other'
+        param_name = matching_params[0]
+        other.__xpm__.set(param_name, self)
+        return other
+
 
 class Config:
     """Base type for all objects in python interface"""
@@ -1441,51 +1808,78 @@ class Config:
     """The object type holds all the information about a specific subclass
     experimaestro metadata"""
 
-    __xpm__: ConfigInformation
-    """The __xpm__ object contains all instance specific information about a
-    configuration/task"""
-
     @classproperty
     def XPMConfig(cls):
         if issubclass(cls, ConfigMixin):
             return cls
-        return cls.__getxpmtype__().configtype
+        return cls.__getxpmtype__().config_type
+
+    @classproperty
+    def C(cls):
+        """Alias for XPMConfig"""
+        return cls.XPMConfig
 
     @classproperty
     def XPMValue(cls):
-        """Returns the value object for this configuration"""
-        if issubclass(cls, ConfigMixin):
-            return cls.__xpmtype__.objecttype
+        """Get the value class for this configuration.
 
-        if value_cls := cls.__dict__.get("__XPMValue__", None):
-            pass
-        else:
-            from ..types import XPMValue
+        Returns the explicitly registered value class, or the base config class
+        if no value class was registered.
+        """
+        return cls.__getxpmtype__().value_type
 
-            __objectbases__ = tuple(
-                s.XPMValue
-                for s in cls.__bases__
-                if issubclass(s, Config) and (s is not Config)
-            ) or (XPMValue,)
+    @classmethod
+    def value_class(cls):
+        """Decorator to register an external value class for this configuration.
 
-            *tp_qual, tp_name = cls.__qualname__.split(".")
-            value_cls = type(f"{tp_name}.XPMValue", (cls,) + __objectbases__, {})
-            value_cls.__qualname__ = ".".join(tp_qual + [value_cls.__name__])
-            value_cls.__module__ = cls.__module__
+        This allows declaring a separate class that will be used when creating
+        instances, which is useful to avoid initializing resources (e.g., PyTorch)
+        when only configuring.
 
-            setattr(cls, "__XPMValue__", value_cls)
+        .. code-block:: python
 
-        return value_cls
+            class Model(Config):
+                hidden_size: Param[int]
 
-    @classproperty
-    def C(cls):
-        """Alias for XPMConfig"""
-        return cls.XPMConfig
+            @Model.value_class()
+            class TorchModel(Model, nn.Module):
+                def __init__(self):
+                    super().__init__()
+                    self.layer = nn.Linear(self.hidden_size, self.hidden_size)
 
-    @classproperty
-    def V(cls):
-        """Alias for XPMValue"""
-        return cls.XPMValue
+        The value class must be a subclass of the configuration class
+        and a subclass of parent configuration value classes (if any).
+        """
+
+        def decorator(value_class: type) -> type:
+            xpmtype = cls.__getxpmtype__()
+
+            # Check that value class is a subclass of the config class
+            if not issubclass(value_class, cls):
+                raise TypeError(
+                    f"Value class {value_class.__name__} must be a subclass of "
+                    f"{cls.__name__}"
+                )
+
+            # Check that value class inherits from parent value classes
+            for base in cls.__bases__:
+                if base is Config or not issubclass(base, Config):
+                    continue
+                parent_xpmtype = base.__getxpmtype__()
+                # Check if parent has an explicit value type (different from original)
+                if parent_xpmtype.value_type is not parent_xpmtype._original_type:
+                    parent_value = parent_xpmtype.value_type
+                    if not issubclass(value_class, parent_value):
+                        raise TypeError(
+                            f"Value class {value_class.__name__} must be a subclass of "
+                            f"parent value class {parent_value.__name__}"
+                        )
+
+            # Register the value class
+            xpmtype.set_value_type(value_class)
+            return value_class
+
+        return decorator
 
     @classmethod
     def __getxpmtype__(cls) -> "ObjectType":
@@ -1503,46 +1897,6 @@ class Config:
                 raise
         return xpmtype
 
-    def __new__(cls: Type[T], *args, **kwargs) -> T:
-        """Returns an instance of a ConfigMixin (for compatibility, use XPMConfig
-        or C if possible)
-
-        :deprecated: Use Config.C or Config.XPMConfig to construct a new
-            configuration, and Config.V (or Config.XPMValue) for a new value
-        """
-        # If this is an XPMValue, just return a new instance
-        from experimaestro.core.types import XPMValue
-
-        if issubclass(cls, XPMValue):
-            return object.__new__(cls)
-
-        # If this is the XPMConfig, just return a new instance
-        # __init__ will be called
-        if issubclass(cls, ConfigMixin):
-            return object.__new__(cls)
-
-        # Log a deprecation warning for this way of creating a configuration
-        caller = inspect.getframeinfo(inspect.stack()[1][0])
-        logger.warning(
-            "Creating a configuration using Config.__new__ is deprecated, and will be removed in a future version. "
-            "Use Config.C or Config.XPMConfig to create a new configuration. "
-            "Issue created at %s:%s",
-            str(Path(caller.filename).absolute()),
-            caller.lineno,
-        )
-
-        # otherwise, we use the configuration type
-        o: ConfigMixin = object.__new__(cls.__getxpmtype__().configtype)
-        try:
-            o.__init__(*args, **kwargs)
-        except Exception:
-            logger.error(
-                "Init error in %s:%s"
-                % (str(Path(caller.filename).absolute()), caller.lineno)
-            )
-            raise
-        return o
-
     def __validate__(self):
         """Validate the values"""
         pass
@@ -1557,17 +1911,7 @@ class Config:
         return self.__xpm__.__json__()
 
     def __identifier__(self) -> "Identifier":
-        return self.__xpm__.full_identifier
-
-    def add_pretasks(self, *tasks: "LightweightTask"):
-        """Add pre-tasks"""
-        raise AssertionError("This method can only be used during configuration")
-
-    def add_pretasks_from(self, *configs: "Config"):
-        """Add pre-tasks from the listed configurations"""
-        raise AssertionError(
-            "The 'add_pretasks_from' can only be used during configuration"
-        )
+        return self.__xpm__.identifier
 
     def copy_dependencies(self, other: "Config"):
         """Add pre-tasks from the listed configurations"""
@@ -1575,11 +1919,6 @@ class Config:
             "The 'copy_dependencies' method can only be used during configuration"
         )
 
-    @property
-    def pre_tasks(self) -> List["LightweightTask"]:
-        """Access pre-tasks"""
-        raise AssertionError("Pre-tasks can be accessed only during configuration")
-
     def register_task_output(self, method, *args, **kwargs):
         # Determine the path for this...
         path = taskglobals.Env.instance().xpm_path / "task-outputs.jsonl"
@@ -1597,6 +1936,40 @@ class Config:
             fp.flush()
 
 
+class InstanceConfig(Config):
+    """Base class for configurations where instance identity matters.
+
+    When a Config class derives from InstanceConfig instead of Config,
+    instances are distinguished based on their object identity when used
+    in containers. This enables distinguishing between shared and separate
+    instances even when all parameters are identical.
+
+    Example:
+        >>> class SubModel(InstanceConfig):
+        ...     value: Param[int] = 100
+        >>> class MainModel(Config):
+        ...     m1: Param[SubModel]
+        ...     m2: Param[SubModel]
+        >>>
+        >>> sm1 = SubModel.C()
+        >>> sm2 = SubModel.C()  # Same params, different instance
+        >>>
+        >>> # Shared instance (same object used twice)
+        >>> shared = MainModel.C(m1=sm1, m2=sm1)
+        >>>
+        >>> # Separate instances (different objects)
+        >>> separate = MainModel.C(m1=sm1, m2=sm2)
+        >>>
+        >>> # Different identifiers: shared vs separate
+        >>> shared.__identifier__() != separate.__identifier__()
+
+    The instance order is determined by the traversal order during
+    identifier computation, ensuring reproducibility.
+    """
+
+    pass
+
+
 class LightweightTask(Config):
     """A task that can be run before or after a real task to modify its behaviour"""
 
@@ -1659,11 +2032,55 @@ def copyconfig(config: Config, **kwargs):
 
 
 def setmeta(config: Config, flag: bool):
-    """Flags the configuration as a meta-parameter"""
+    """Force a configuration to be treated as a meta-parameter.
+
+    When a configuration is marked as meta, it is excluded from the
+    identifier computation of its parent configuration.
+
+    Example::
+
+        class Ensemble(Config):
+            model1: Param[Model]
+            model2: Param[Model]
+
+        # Mark model2 as meta - it won't affect the ensemble's identifier
+        model2 = setmeta(Model.C(...), True)
+        ensemble = Ensemble.C(model1=model1, model2=model2)
+
+    :param config: The configuration to mark
+    :param flag: True to mark as meta, False to include in identifier
+    :return: The same configuration (for chaining)
+    """
     config.__xpm__.set_meta(flag)
     return config
 
 
+class ResumableTask(Task):
+    """Base class for resumable/checkpointable tasks
+
+    Resumable tasks can be restarted if they are stopped by a time limit
+    (e.g., SLURM job timeout). The task directory and dynamic outputs are
+    preserved across restarts to allow checkpoint recovery.
+    """
+
+    def remaining_time(self) -> Optional[float]:
+        """Returns the remaining time in seconds before the job times out.
+
+        This is useful for checkpointing before hitting a time limit
+        (e.g., SLURM walltime).
+
+        Returns:
+            The remaining time in seconds, or None if:
+            - There is no time limit
+            - The launcher doesn't support querying remaining time
+            - The task is not running
+        """
+        launcher_info = taskglobals.Env.instance().launcher_info
+        if launcher_info is None:
+            return None
+        return launcher_info.remaining_time()
+
+
 def cache(fn, name: str):
     def __call__(config, *args, **kwargs):
         import experimaestro.taskglobals as taskglobals