furu 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

furu/core/furu.py

@@ -5,9 +5,11 @@ import os
 import signal
 import socket
 import sys
+import threading
 import time
 import traceback
 from abc import ABC, abstractmethod
+from functools import cached_property
 from pathlib import Path
 from types import FrameType
 from typing import (
@@ -20,18 +22,16 @@ from typing import (
     Protocol,
     Self,
     Sequence,
-    TypedDict,
     TypeAlias,
+    TypedDict,
     TypeVar,
     cast,
-    overload,
 )
 
 import chz
 import submitit
-from typing_extensions import dataclass_transform
-
 from chz.field import Field as ChzField
+from typing_extensions import dataclass_transform
 
 from ..adapters import SubmititAdapter
 from ..adapters.submitit import SubmititJob
@@ -40,6 +40,7 @@ from ..errors import (
     MISSING,
     FuruComputeError,
     FuruLockNotAcquired,
+    FuruValidationError,
     FuruWaitTimeout,
 )
 from ..runtime import current_holder
@@ -62,7 +63,6 @@ from ..storage.state import (
     _StateAttemptRunning,
     _StateResultAbsent,
     _StateResultFailed,
-    _StateResultMigrated,
     _StateResultSuccess,
     compute_lock,
 )
@@ -190,16 +190,23 @@ class Furu[T](ABC):
         raise NotImplementedError(f"{self.__class__.__name__}._load() not implemented")
 
     def _validate(self: Self) -> bool:
-        """Validate that result is complete and correct (override if needed)."""
+        """
+        Validate that result is complete and correct (override if needed).
+
+        Return False or raise FuruValidationError to mark artifacts as invalid.
+        """
         return True
 
     def _dependencies(self: Self) -> "DependencySpec | None":
         """Return extra dependencies not captured by fields."""
         return None
 
+    def _executor_spec_key(self: Self) -> str:
+        return "default"
+
     def _get_dependencies(self: Self, *, recursive: bool = True) -> list["Furu"]:
         """Collect Furu dependencies from fields and `_dependencies()`."""
-        seen = {self._furu_hash}
+        seen = {self.furu_hash}
         dependencies: list[Furu] = []
         _collect_dependencies(self, dependencies, seen, recursive=recursive)
         return dependencies
@@ -213,7 +220,7 @@ class Furu[T](ABC):
         for dependency in dependencies:
             if dependency is self:
                 raise ValueError("Furu dependencies cannot include self")
-            digests.add(dependency._furu_hash)
+            digests.add(dependency.furu_hash)
         return sorted(digests)
 
     def _invalidate_cached_success(self: Self, directory: Path, *, reason: str) -> None:
@@ -221,7 +228,7 @@ class Furu[T](ABC):
         logger.warning(
             "invalidate %s %s %s (%s)",
             self.__class__.__name__,
-            self._furu_hash,
+            self.furu_hash,
             directory,
             reason,
         )
@@ -238,9 +245,25 @@ class Furu[T](ABC):
             directory, {"type": "result_invalidated", "reason": reason, "at": now}
         )
 
-    @property
-    def _furu_hash(self: Self) -> str:
-        """Compute hash of this object's content for storage identification."""
+    def _prepare_executor_rerun(self: Self, directory: Path) -> None:
+        if not self._always_rerun():
+            return
+        if not directory.exists():
+            return
+        migration = self._alias_record(directory)
+        if migration is not None and self._alias_is_active(directory, migration):
+            self._maybe_detach_alias(
+                directory=directory,
+                record=migration,
+                reason="always_rerun",
+            )
+        state = StateManager.read_state(directory)
+        if isinstance(state.result, _StateResultSuccess):
+            self._invalidate_cached_success(directory, reason="always_rerun enabled")
+
+    @cached_property
+    def furu_hash(self: Self) -> str:
+        """Return the stable content hash for this Furu object."""
         return FuruSerializer.compute_hash(self)
 
     def _always_rerun(self: Self) -> bool:
@@ -253,15 +276,17 @@ class Furu[T](ABC):
 
     def _base_furu_dir(self: Self) -> Path:
         root = FURU_CONFIG.get_root(self.version_controlled)
-        return root / self.__class__._namespace() / self._furu_hash
+        return root / self.__class__._namespace() / self.furu_hash
 
-    @property
+    @cached_property
     def furu_dir(self: Self) -> Path:
         """Get the directory for this Furu object."""
         directory = self._base_furu_dir()
         migration = self._alias_record(directory)
-        if migration is not None and self._alias_is_active(directory, migration):
-            return MigrationManager.resolve_dir(migration, target="from")
+        if migration is not None:
+            target_dir = self._alias_target_dir(directory, migration)
+            if target_dir is not None:
+                return target_dir
         return directory
 
     @property
@@ -290,13 +315,38 @@ class Furu[T](ABC):
         """Log a message to the current holder's `furu.log`."""
         return log(message, level=level)
 
+    def _exists_quiet(self: Self) -> bool:
+        directory = self._base_furu_dir()
+        success_dir = self._success_marker_dir(directory)
+        if success_dir is None:
+            return False
+        try:
+            return self._validate()
+        except FuruValidationError as exc:
+            logger = get_logger()
+            logger.warning(
+                "exists %s -> false (validate invalid for %s: %s)",
+                directory,
+                f"{self.__class__.__name__}({self.furu_hash})",
+                exc,
+            )
+            return False
+        except Exception as exc:
+            logger = get_logger()
+            logger.exception(
+                "exists %s -> false (validate crashed for %s: %s)",
+                directory,
+                f"{self.__class__.__name__}({self.furu_hash})",
+                exc,
+            )
+            return False
+
     def exists(self: Self) -> bool:
         """Check if result exists and is valid."""
         logger = get_logger()
         directory = self._base_furu_dir()
-        state = self.get_state(directory)
-
-        if not isinstance(state.result, _StateResultSuccess):
+        success_dir = self._success_marker_dir(directory)
+        if success_dir is None:
             logger.info("exists %s -> false", directory)
             return False
 
@@ -313,53 +363,139 @@ class Furu[T](ABC):
         """Get migration record for this object."""
         return MigrationManager.read_migration(self._base_furu_dir())
 
-    @overload
-    def load_or_create(
-        self,
-        executor: submitit.Executor,
-        *,
-        retry_failed: bool | None = None,
-    ) -> T | submitit.Job[T]: ...
-
-    @overload
-    def load_or_create(
-        self,
-        executor: None = None,
-        *,
-        retry_failed: bool | None = None,
-    ) -> T: ...
-
-    def load_or_create(
-        self: Self,
-        executor: submitit.Executor | None = None,
-        *,
-        retry_failed: bool | None = None,
-    ) -> T | submitit.Job[T]:
+    def get(self: Self, *, force: bool = False) -> T:
         """
         Load result if it exists, computing if necessary.
 
         Args:
-            executor: Optional executor for batch submission (e.g., submitit.Executor)
-            retry_failed: Whether to retry failed results (default uses FURU_RETRY_FAILED)
+            force: Allow computation inside executor contexts if the spec matches.
 
         Returns:
-            Result if wait=True, job handle if wait=False, or None if already exists
+            Loaded or computed result.
 
         Raises:
             FuruComputeError: If computation fails with detailed error information
         """
+        from furu.errors import (
+            FuruExecutionError,
+            FuruMissingArtifact,
+            FuruSpecMismatch,
+        )
+        from furu.execution.context import EXEC_CONTEXT
+
+        ctx = EXEC_CONTEXT.get()
+        if ctx.mode == "executor":
+            logger = get_logger()
+            parent_holder = current_holder()
+            has_parent = parent_holder is not None and parent_holder is not self
+            needs_holder = parent_holder is None or has_parent
+            caller_info: _CallerInfo = {}
+            if has_parent:
+                caller_info = self._get_caller_info()
+
+            def _executor_get() -> T:
+                directory = self._base_furu_dir()
+                if force:
+                    if (
+                        ctx.current_node_hash is None
+                        or self.furu_hash != ctx.current_node_hash
+                    ):
+                        raise FuruExecutionError(
+                            "force=True not allowed: only the current node may compute in executor mode. "
+                            f"current_node_hash={ctx.current_node_hash!r} "
+                            f"obj={self.__class__.__name__}({self.furu_hash})",
+                            hints=[
+                                "Declare this object as a dependency instead of calling dep.get(force=True).",
+                                "Inside executor mode, use get(force=True) only on the node being executed.",
+                            ],
+                        )
+                    self._prepare_executor_rerun(directory)
+
+                exists_ok = self._exists_quiet()
+                if exists_ok and not (force and self._always_rerun()):
+                    return self._load()
+
+                if force and not exists_ok:
+                    state = self.get_state(directory)
+                    if isinstance(state.result, _StateResultSuccess):
+                        self._invalidate_cached_success(
+                            directory, reason="_validate returned false (executor)"
+                        )
+
+                if not force:
+                    raise FuruMissingArtifact(
+                        "Missing artifact "
+                        f"{self.__class__.__name__}({self.furu_hash}) in executor mode. "
+                        f"Requested by {ctx.current_node_hash}. Declare it as a dependency."
+                    )
+
+                required = self._executor_spec_key()
+                if ctx.spec_key is None or required != ctx.spec_key:
+                    raise FuruSpecMismatch(
+                        "force=True not allowed: "
+                        f"required={required!r} != worker={ctx.spec_key!r} (v1 exact match)"
+                    )
+
+                StateManager.ensure_internal_dir(directory)
+                status, created_here, result = self._run_locally(
+                    start_time=time.time(),
+                    allow_failed=FURU_CONFIG.retry_failed,
+                    executor_mode=True,
+                )
+                if status == "success":
+                    if created_here:
+                        return cast(T, result)
+                    return self._load()
+
+                raise self._build_failed_state_error(
+                    self._base_furu_dir(),
+                    None,
+                    message="Computation previously failed",
+                )
+
+            if has_parent:
+                logger.debug(
+                    "dep: begin %s %s %s",
+                    self.__class__.__name__,
+                    self.furu_hash,
+                    self._base_furu_dir(),
+                    extra=caller_info,
+                )
+
+            ok = False
+            try:
+                if needs_holder:
+                    with enter_holder(self):
+                        result = _executor_get()
+                else:
+                    result = _executor_get()
+                ok = True
+                return result
+            finally:
+                if has_parent:
+                    logger.debug(
+                        "dep: end %s %s (%s)",
+                        self.__class__.__name__,
+                        self.furu_hash,
+                        "ok" if ok else "error",
+                        extra=caller_info,
+                    )
+
+        return self._get_impl_interactive(force=force)
+
+    def _get_impl_interactive(self: Self, *, force: bool) -> T:
         logger = get_logger()
         parent_holder = current_holder()
         has_parent = parent_holder is not None and parent_holder is not self
-        retry_failed_effective = (
-            retry_failed if retry_failed is not None else FURU_CONFIG.retry_failed
-        )
+        caller_info = self._get_caller_info()
+        retry_failed_effective = FURU_CONFIG.retry_failed
         if has_parent:
             logger.debug(
                 "dep: begin %s %s %s",
                 self.__class__.__name__,
-                self._furu_hash,
+                self.furu_hash,
                 self._base_furu_dir(),
+                extra=caller_info,
             )
 
         ok = False
@@ -367,19 +503,21 @@ class Furu[T](ABC):
             with enter_holder(self):
                 start_time = time.time()
                 base_dir = self._base_furu_dir()
-                base_dir.mkdir(parents=True, exist_ok=True)
                 directory = base_dir
                 migration = self._alias_record(base_dir)
                 alias_active = False
+                base_marker = StateManager.success_marker_exists(base_dir)
 
                 if (
                     migration is not None
                     and migration.kind == "alias"
                     and migration.overwritten_at is None
+                    and not base_marker
                 ):
-                    target_dir = MigrationManager.resolve_dir(migration, target="from")
-                    target_state = StateManager.read_state(target_dir)
-                    if isinstance(target_state.result, _StateResultSuccess):
+                    target_dir = self._alias_target_dir(
+                        base_dir, migration, base_marker=base_marker
+                    )
+                    if target_dir is not None:
                         alias_active = True
                         directory = target_dir
                     else:
@@ -445,7 +583,6 @@ class Furu[T](ABC):
                         message="Computation previously failed",
                     )
 
-                needs_reconcile = True
                 if isinstance(state0.result, _StateResultSuccess):
                     # Double check logic if we fell through to here (e.g. race condition or invalidation above)
                     if self._always_rerun():
@@ -460,9 +597,6 @@ class Furu[T](ABC):
                                     directory, reason="_validate returned false"
                                 )
                                 state0 = StateManager.read_state(directory)
-                            else:
-                                # Valid success found, skip reconcile
-                                needs_reconcile = False
                         except Exception as e:
                             self._invalidate_cached_success(
                                 directory,
@@ -470,11 +604,6 @@ class Furu[T](ABC):
                             )
                             state0 = StateManager.read_state(directory)
 
-                if needs_reconcile and executor is not None:
-                    adapter0 = SubmititAdapter(executor)
-                    self._reconcile(directory, adapter=adapter0)
-                    state0 = StateManager.read_state(directory)
-
                 attempt0 = state0.attempt
                 if isinstance(state0.result, _StateResultSuccess):
                     decision = "success->load"
@@ -489,17 +618,25 @@ class Furu[T](ABC):
                 # Cache hits can be extremely noisy in pipelines; keep logs for state
                 # transitions (create/wait) and error cases, but suppress repeated
                 # "success->load" lines and the raw separator on successful loads.
-                self._log_console_start(action_color=action_color)
+                self._log_console_start(
+                    action_color=action_color,
+                    caller_info=caller_info,
+                )
 
                 if decision != "success->load":
+                    if decision == "create":
+                        StateManager.ensure_internal_dir(directory)
                     write_separator()
                     logger.debug(
-                        "load_or_create %s %s %s (%s)",
+                        "get %s %s %s (%s)",
                         self.__class__.__name__,
-                        self._furu_hash,
+                        self.furu_hash,
                         directory,
                         decision,
-                        extra={"furu_action_color": action_color},
+                        extra={
+                            "furu_action_color": action_color,
+                            **caller_info,
+                        },
                     )
 
                 # Fast path: already successful
@@ -514,9 +651,9 @@ class Furu[T](ABC):
                         # failures even when we suppressed the cache-hit header line.
                         write_separator()
                         logger.error(
-                            "load_or_create %s %s (load failed)",
+                            "get %s %s (load failed)",
                             self.__class__.__name__,
-                            self._furu_hash,
+                            self.furu_hash,
                         )
                         raise FuruComputeError(
                             f"Failed to load result from {directory}",
@@ -524,65 +661,43 @@ class Furu[T](ABC):
                             e,
                         ) from e
 
-                # Synchronous execution
-                if executor is None:
-                    status, created_here, result = self._run_locally(
-                        start_time=start_time,
-                        allow_failed=retry_failed_effective,
-                    )
-                    if status == "success":
-                        ok = True
-                        if created_here:
-                            logger.debug(
-                                "load_or_create: %s created -> return",
-                                self.__class__.__name__,
-                            )
-                            return cast(T, result)
+                status, created_here, result = self._run_locally(
+                    start_time=start_time,
+                    allow_failed=retry_failed_effective,
+                    executor_mode=False,
+                )
+                if status == "success":
+                    ok = True
+                    if created_here:
                         logger.debug(
-                            "load_or_create: %s success -> _load()",
+                            "get: %s created -> return",
                             self.__class__.__name__,
                         )
-                        return self._load()
-
-                    raise self._build_failed_state_error(
-                        directory,
-                        None,
-                        message="Computation previously failed",
+                        return cast(T, result)
+                    logger.debug(
+                        "get: %s success -> _load()",
+                        self.__class__.__name__,
                     )
+                    return self._load()
 
-                # Asynchronous execution with submitit
-                (submitit_folder := self._base_furu_dir() / "submitit").mkdir(
-                    exist_ok=True, parents=True
-                )
-                executor.folder = submitit_folder
-                adapter = SubmititAdapter(executor)
-
-                logger.debug(
-                    "load_or_create: %s -> submitit submit_once()",
-                    self.__class__.__name__,
-                )
-                job = self._submit_once(
-                    adapter,
+                raise self._build_failed_state_error(
                     directory,
                     None,
-                    allow_failed=retry_failed_effective,
+                    message="Computation previously failed",
                 )
-                ok = True
-                return cast(submitit.Job[T], job)
         finally:
             if has_parent:
                 logger.debug(
                     "dep: end %s %s (%s)",
                     self.__class__.__name__,
-                    self._furu_hash,
+                    self.furu_hash,
                     "ok" if ok else "error",
+                    extra=caller_info,
                 )
 
-    def _log_console_start(self, action_color: str) -> None:
-        """Log the start of load_or_create to console with caller info."""
-        logger = get_logger()
+    @staticmethod
+    def _get_caller_info() -> _CallerInfo:
         frame = sys._getframe(1)
-
         caller_info: _CallerInfo = {}
         if frame is not None:
             # Walk up the stack to find the caller outside of furu package
@@ -597,11 +712,20 @@ class Furu[T](ABC):
                     }
                     break
                 frame = frame.f_back
+        return caller_info
+
+    def _log_console_start(
+        self, action_color: str, caller_info: _CallerInfo | None = None
+    ) -> None:
+        """Log the start of get to console with caller info."""
+        logger = get_logger()
+        if caller_info is None:
+            caller_info = self._get_caller_info()
 
         logger.info(
-            "load_or_create %s %s",
+            "get %s %s",
             self.__class__.__name__,
-            self._furu_hash,
+            self.furu_hash,
             extra={
                 "furu_console_only": True,
                 "furu_action_color": action_color,
@@ -612,20 +736,14 @@ class Furu[T](ABC):
     def _add_exception_breadcrumbs(self, exc: BaseException, directory: Path) -> None:
         if not hasattr(exc, "add_note"):
             return
-        state_path = StateManager.get_state_path(directory)
-        log_path = StateManager.get_internal_dir(directory) / "furu.log"
-        note = (
-            f"Furu directory: {directory}\n"
-            f"State file: {state_path}\n"
-            f"Log file: {log_path}"
-        )
+        note = f"Furu dir: {directory}"
         exc.add_note(note)
 
     @staticmethod
     def _failed_state_hints() -> list[str]:
         return [
-            "To retry this failed artifact: set FURU_RETRY_FAILED=1 or call load_or_create(retry_failed=True).",
-            "To inspect details: open the state file and furu.log shown above.",
+            "To retry this failed artifact: set FURU_RETRY_FAILED=1 or call get() again.",
+            "To inspect details: open the furu dir shown above.",
         ]
 
     def _build_failed_state_error(
@@ -678,9 +796,11 @@ class Furu[T](ABC):
         """Return the alias-aware state for this Furu directory."""
         base_dir = directory or self._base_furu_dir()
         record = self._alias_record(base_dir)
-        if record is None or not self._alias_is_active(base_dir, record):
+        if record is None:
+            return StateManager.read_state(base_dir)
+        target_dir = self._alias_target_dir(base_dir, record)
+        if target_dir is None:
             return StateManager.read_state(base_dir)
-        target_dir = MigrationManager.resolve_dir(record, target="from")
         return StateManager.read_state(target_dir)
 
     def _alias_record(self, directory: Path) -> MigrationRecord | None:
@@ -689,15 +809,36 @@ class Furu[T](ABC):
             return None
         return record
 
-    def _alias_is_active(self, directory: Path, record: MigrationRecord) -> bool:
+    def _alias_target_dir(
+        self,
+        directory: Path,
+        record: MigrationRecord,
+        *,
+        base_marker: bool | None = None,
+    ) -> Path | None:
         if record.overwritten_at is not None:
-            return False
-        state = StateManager.read_state(directory)
-        if not isinstance(state.result, _StateResultMigrated):
-            return False
+            return None
+        if base_marker is None:
+            base_marker = StateManager.success_marker_exists(directory)
+        if base_marker:
+            return None
         target = MigrationManager.resolve_dir(record, target="from")
-        target_state = StateManager.read_state(target)
-        return isinstance(target_state.result, _StateResultSuccess)
+        if StateManager.success_marker_exists(target):
+            return target
+        return None
+
+    def _success_marker_dir(self, directory: Path) -> Path | None:
+        base_marker = StateManager.success_marker_exists(directory)
+        record = self._alias_record(directory)
+        if record is None:
+            return directory if base_marker else None
+        target_dir = self._alias_target_dir(directory, record, base_marker=base_marker)
+        if target_dir is not None:
+            return target_dir
+        return directory if base_marker else None
+
+    def _alias_is_active(self, directory: Path, record: MigrationRecord) -> bool:
+        return self._alias_target_dir(directory, record) is not None
 
     def _maybe_detach_alias(
         self: Self,
@@ -738,6 +879,7 @@ class Furu[T](ABC):
     ) -> SubmititJob | None:
         """Submit job once without waiting (fire-and-forget mode)."""
         logger = get_logger()
+        StateManager.ensure_internal_dir(directory)
         self._reconcile(directory, adapter=adapter)
         state = StateManager.read_state(directory)
         attempt = state.attempt
@@ -758,7 +900,7 @@ class Furu[T](ABC):
             logger.debug(
                 "submit: waiting for submit lock %s %s %s",
                 self.__class__.__name__,
-                self._furu_hash,
+                self.furu_hash,
                 directory,
             )
             time.sleep(0.5)
@@ -767,9 +909,7 @@ class Furu[T](ABC):
         attempt_id: str | None = None
         try:
             # Create metadata
-            metadata = MetadataManager.create_metadata(
-                self, directory, ignore_diff=FURU_CONFIG.ignore_git_diff
-            )
+            metadata = MetadataManager.create_metadata(self, directory)
             MetadataManager.write_metadata(metadata, directory)
 
             env_info = MetadataManager.collect_environment_info()
@@ -843,127 +983,197 @@ class Furu[T](ABC):
         """Entry point for worker process (called by submitit or locally)."""
         with enter_holder(self):
             logger = get_logger()
-            directory = self._base_furu_dir()
-            directory.mkdir(parents=True, exist_ok=True)
-
-            env_info = self._collect_submitit_env()
-            allow_failed_effective = (
-                allow_failed if allow_failed is not None else FURU_CONFIG.retry_failed
+            # Ensure executor semantics apply to *all* work in the worker, not
+            # just `_create()`. This prevents accidental dependency computation
+            # (e.g., from within `_validate()` or metadata hooks).
+            from furu.execution.context import EXEC_CONTEXT, ExecContext
+
+            exec_token = EXEC_CONTEXT.set(
+                ExecContext(
+                    mode="executor",
+                    spec_key=self._executor_spec_key(),
+                    backend="submitit",
+                    current_node_hash=self.furu_hash,
+                )
             )
-
             try:
-                with compute_lock(
-                    directory,
-                    backend="submitit",
-                    lease_duration_sec=FURU_CONFIG.lease_duration_sec,
-                    heartbeat_interval_sec=FURU_CONFIG.heartbeat_interval_sec,
-                    owner={
-                        "pid": os.getpid(),
-                        "host": socket.gethostname(),
-                        "user": getpass.getuser(),
-                        "command": " ".join(sys.argv) if sys.argv else "<unknown>",
-                    },
-                    scheduler={
-                        "backend": env_info.get("backend"),
-                        "job_id": env_info.get("slurm_job_id"),
-                    },
-                    max_wait_time_sec=None,  # Workers wait indefinitely
-                    poll_interval_sec=FURU_CONFIG.poll_interval,
-                    wait_log_every_sec=FURU_CONFIG.wait_log_every_sec,
-                    reconcile_fn=lambda d: self._reconcile(d),
-                    allow_failed=allow_failed_effective,
-                ) as ctx:
-                    stage = "metadata"
-                    try:
-                        # Refresh metadata (now safe - attempt is already recorded)
-                        metadata = MetadataManager.create_metadata(
-                            self, directory, ignore_diff=FURU_CONFIG.ignore_git_diff
-                        )
-                        MetadataManager.write_metadata(metadata, directory)
+                directory = self._base_furu_dir()
+                StateManager.ensure_internal_dir(directory)
+                always_rerun = self._always_rerun()
+                needs_success_invalidation = False
+                if not always_rerun:
+                    exists_ok = self._exists_quiet()
+                    if not exists_ok:
+                        state = self.get_state(directory)
+                        if isinstance(state.result, _StateResultSuccess):
+                            needs_success_invalidation = True
+
+                env_info = self._collect_submitit_env()
+                allow_failed_effective = (
+                    allow_failed
+                    if allow_failed is not None
+                    else FURU_CONFIG.retry_failed
+                )
+                allow_success = always_rerun or needs_success_invalidation
 
-                        # Set up signal handlers
-                        stage = "signal handler setup"
-                        self._setup_signal_handlers(
-                            directory, ctx.stop_heartbeat, attempt_id=ctx.attempt_id
-                        )
+                try:
+                    with compute_lock(
+                        directory,
+                        backend="submitit",
+                        lease_duration_sec=FURU_CONFIG.lease_duration_sec,
+                        heartbeat_interval_sec=FURU_CONFIG.heartbeat_interval_sec,
+                        owner={
+                            "pid": os.getpid(),
+                            "host": socket.gethostname(),
+                            "user": getpass.getuser(),
+                            "command": " ".join(sys.argv) if sys.argv else "<unknown>",
+                        },
+                        scheduler={
+                            "backend": env_info.get("backend"),
+                            "job_id": env_info.get("slurm_job_id"),
+                        },
+                        max_wait_time_sec=None,  # Workers wait indefinitely
+                        poll_interval_sec=FURU_CONFIG.poll_interval,
+                        wait_log_every_sec=FURU_CONFIG.wait_log_every_sec,
+                        reconcile_fn=lambda d: self._reconcile(d),
+                        allow_failed=allow_failed_effective,
+                        allow_success=allow_success,
+                    ) as ctx:
+                        self._prepare_executor_rerun(directory)
+                        if not always_rerun:
+                            exists_ok = self._exists_quiet()
+                            if not exists_ok:
+                                state = self.get_state(directory)
+                                if isinstance(state.result, _StateResultSuccess):
+                                    self._invalidate_cached_success(
+                                        directory,
+                                        reason="_validate returned false (worker)",
+                                    )
+
+                        stage = "metadata"
+                        try:
+                            # Refresh metadata (now safe - attempt is already recorded)
+                            metadata = MetadataManager.create_metadata(self, directory)
+                            MetadataManager.write_metadata(metadata, directory)
 
-                        stage = "_create"
-                        # Run computation
-                        logger.debug(
-                            "_create: begin %s %s %s",
-                            self.__class__.__name__,
-                            self._furu_hash,
-                            directory,
-                        )
-                        self._create()
-                        logger.debug(
-                            "_create: ok %s %s %s",
-                            self.__class__.__name__,
-                            self._furu_hash,
-                            directory,
-                        )
-                        StateManager.write_success_marker(
-                            directory, attempt_id=ctx.attempt_id
-                        )
-                        StateManager.finish_attempt_success(
-                            directory, attempt_id=ctx.attempt_id
-                        )
-                        logger.info(
-                            "_create ok %s %s",
-                            self.__class__.__name__,
-                            self._furu_hash,
-                            extra={"furu_console_only": True},
-                        )
-                    except Exception as e:
-                        if stage == "_create":
-                            logger.error(
-                                "_create failed %s %s %s",
+                            # Set up signal handlers
+                            stage = "signal handler setup"
+                            self._setup_signal_handlers(
+                                directory,
+                                ctx.stop_heartbeat,
+                                attempt_id=ctx.attempt_id,
+                            )
+
+                            stage = "_create"
+                            # Run computation
+                            logger.debug(
+                                "_create: begin %s %s %s",
                                 self.__class__.__name__,
-                                self._furu_hash,
+                                self.furu_hash,
                                 directory,
-                                extra={"furu_file_only": True},
                             )
-                        else:
-                            logger.error(
-                                "attempt failed (%s) %s %s %s",
-                                stage,
+                            self._create()
+                            logger.debug(
+                                "_create: ok %s %s %s",
                                 self.__class__.__name__,
-                                self._furu_hash,
+                                self.furu_hash,
                                 directory,
+                            )
+                            StateManager.write_success_marker(
+                                directory, attempt_id=ctx.attempt_id
+                            )
+                            StateManager.finish_attempt_success(
+                                directory, attempt_id=ctx.attempt_id
+                            )
+                            logger.info(
+                                "_create ok %s %s",
+                                self.__class__.__name__,
+                                self.furu_hash,
+                                extra={"furu_console_only": True},
+                            )
+                        except Exception as e:
+                            if stage == "_create":
+                                logger.error(
+                                    "_create failed %s %s %s",
+                                    self.__class__.__name__,
+                                    self.furu_hash,
+                                    directory,
+                                    extra={"furu_file_only": True},
+                                )
+                            else:
+                                logger.error(
+                                    "attempt failed (%s) %s %s %s",
+                                    stage,
+                                    self.__class__.__name__,
+                                    self.furu_hash,
+                                    directory,
+                                    extra={"furu_file_only": True},
+                                )
+                            logger.error(
+                                "%s",
+                                format_traceback(e),
                                 extra={"furu_file_only": True},
                             )
-                        logger.error(
-                            "%s", format_traceback(e), extra={"furu_file_only": True}
-                        )
 
-                        tb = "".join(
-                            traceback.format_exception(type(e), e, e.__traceback__)
-                        )
-                        StateManager.finish_attempt_failed(
-                            directory,
-                            attempt_id=ctx.attempt_id,
-                            error={
-                                "type": type(e).__name__,
-                                "message": str(e),
-                                "traceback": tb,
-                            },
-                        )
-                        self._add_exception_breadcrumbs(e, directory)
-                        if stage != "_create":
-                            message = (
-                                "Failed to create metadata"
-                                if stage == "metadata"
-                                else "Failed to set up signal handlers"
+                            tb = "".join(
+                                traceback.format_exception(type(e), e, e.__traceback__)
                             )
-                            raise FuruComputeError(
-                                message,
-                                StateManager.get_state_path(directory),
-                                e,
-                            ) from e
-                        raise
-            except FuruLockNotAcquired:
-                # Experiment already completed (success or failed), nothing to do
-                return
+                            StateManager.finish_attempt_failed(
+                                directory,
+                                attempt_id=ctx.attempt_id,
+                                error={
+                                    "type": type(e).__name__,
+                                    "message": str(e),
+                                    "traceback": tb,
+                                },
+                            )
+                            self._add_exception_breadcrumbs(e, directory)
+                            if stage != "_create":
+                                message = (
+                                    "Failed to create metadata"
+                                    if stage == "metadata"
+                                    else "Failed to set up signal handlers"
+                                )
+                                raise FuruComputeError(
+                                    message,
+                                    StateManager.get_state_path(directory),
+                                    e,
+                                ) from e
+                            raise
+                except FuruLockNotAcquired as exc:
+                    # Experiment already completed; succeed if success, fail if failed.
+                    state = StateManager.read_state(directory)
+                    state_path = StateManager.get_state_path(directory)
+                    attempt = state.attempt
+                    attempt_info = "no active attempt"
+                    if attempt is not None:
+                        attempt_info = (
+                            f"attempt {attempt.id} status {attempt.status} "
+                            f"backend {attempt.backend}"
+                        )
+                    hints = [
+                        f"Furu hash: {self.furu_hash}",
+                        f"Directory: {directory}",
+                        f"State file: {state_path}",
+                        f"Attempt: {attempt_info}",
+                    ]
+                    if isinstance(state.result, _StateResultSuccess):
+                        return
+                    if isinstance(state.result, _StateResultFailed):
+                        if allow_failed_effective:
+                            return
+                        raise FuruComputeError(
+                            "Worker refused to run: experiment already failed",
+                            state_path,
+                            exc,
+                            hints=hints,
+                        ) from exc
+                    raise FuruLockNotAcquired(
+                        "Worker refused to run: experiment already running elsewhere",
+                        hints=hints,
+                    ) from exc
+            finally:
+                EXEC_CONTEXT.reset(exec_token)
 
     def _collect_submitit_env(self: Self) -> _SubmititEnvInfo:
         """Collect submitit/slurm environment information."""
@@ -994,6 +1204,7 @@ class Furu[T](ABC):
         start_time: float,
         *,
         allow_failed: bool,
+        executor_mode: bool = False,
     ) -> tuple[str, bool, T | None]:
         """Run computation locally, returning (status, created_here, result)."""
         logger = get_logger()
@@ -1028,9 +1239,7 @@ class Furu[T](ABC):
                 stage = "metadata"
                 try:
                     # Create metadata (now safe - attempt is already recorded)
-                    metadata = MetadataManager.create_metadata(
-                        self, directory, ignore_diff=FURU_CONFIG.ignore_git_diff
-                    )
+                    metadata = MetadataManager.create_metadata(self, directory)
                     MetadataManager.write_metadata(metadata, directory)
 
                     # Set up preemption handler
@@ -1044,14 +1253,30 @@ class Furu[T](ABC):
                     logger.debug(
                         "_create: begin %s %s %s",
                         self.__class__.__name__,
-                        self._furu_hash,
+                        self.furu_hash,
                         directory,
                     )
-                    result = self._create()
+                    token = None
+                    if executor_mode:
+                        from furu.execution.context import EXEC_CONTEXT, ExecContext
+
+                        token = EXEC_CONTEXT.set(
+                            ExecContext(
+                                mode="executor",
+                                spec_key=self._executor_spec_key(),
+                                backend="local",
+                                current_node_hash=self.furu_hash,
+                            )
+                        )
+                    try:
+                        result = self._create()
+                    finally:
+                        if token is not None:
+                            EXEC_CONTEXT.reset(token)
                     logger.debug(
                         "_create: ok %s %s %s",
                         self.__class__.__name__,
-                        self._furu_hash,
+                        self.furu_hash,
                         directory,
                     )
                     StateManager.write_success_marker(
@@ -1063,7 +1288,7 @@ class Furu[T](ABC):
                     logger.info(
                         "_create ok %s %s",
                         self.__class__.__name__,
-                        self._furu_hash,
+                        self.furu_hash,
                         extra={"furu_console_only": True},
                     )
                     return "success", True, result
@@ -1072,7 +1297,7 @@ class Furu[T](ABC):
                         logger.error(
                             "_create failed %s %s %s",
                             self.__class__.__name__,
-                            self._furu_hash,
+                            self.furu_hash,
                             directory,
                             extra={"furu_file_only": True},
                         )
@@ -1081,7 +1306,7 @@ class Furu[T](ABC):
                             "attempt failed (%s) %s %s %s",
                             stage,
                             self.__class__.__name__,
-                            self._furu_hash,
+                            self.furu_hash,
                             directory,
                             extra={"furu_file_only": True},
                         )
@@ -1145,6 +1370,8 @@ class Furu[T](ABC):
         attempt_id: str,
     ) -> None:
         """Set up signal handlers for graceful preemption."""
+        if threading.current_thread() is not threading.main_thread():
+            return
 
         def handle_signal(signum: int, frame: FrameType | None) -> None:
             try:
@@ -1191,7 +1418,7 @@ def _collect_dependencies(
     recursive: bool,
 ) -> None:
     for dependency in _direct_dependencies(obj):
-        digest = dependency._furu_hash
+        digest = dependency.furu_hash
         if digest in seen:
             continue
         seen.add(digest)
@@ -1345,7 +1572,7 @@ def _sorted_dependency_set(
 
 def _dependency_sort_key(value: DependencyScanValue) -> tuple[int, str]:
     if isinstance(value, Furu):
-        return (0, value._furu_hash)
+        return (0, cast(str, value.furu_hash))
     return (1, f"{type(value).__name__}:{value!r}")