siliconcompiler 0.35.2__py3-none-any.whl → 0.35.3__py3-none-any.whl

siliconcompiler/library.py

@@ -7,7 +7,7 @@ from siliconcompiler.schema_support.filesetschema import FileSetSchema
 from siliconcompiler.schema_support.pathschema import PathSchema
 from siliconcompiler.schema import NamedSchema, BaseSchema
 
-from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode
+from siliconcompiler.schema import EditableSchema, Parameter, Scope, PerNode, LazyLoad
 from siliconcompiler.schema.utils import trim
 
 
@@ -99,7 +99,8 @@ class ToolLibrarySchema(LibrarySchema):
 
     def _from_dict(self, manifest: Dict,
                    keypath: Union[List[str], Tuple[str, ...]],
-                   version: Optional[Tuple[int, ...]] = None) \
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
             -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         """
         Constructs a schema from a dictionary.
@@ -112,7 +113,7 @@ class ToolLibrarySchema(LibrarySchema):
         Returns:
             dict: The constructed dictionary.
         """
-        if "tool" in manifest:
+        if not lazyload.is_enforced and "tool" in manifest:
             # collect tool keys
             tool_keys = self.allkeys("tool")
 
@@ -136,7 +137,7 @@ class ToolLibrarySchema(LibrarySchema):
             if not manifest["tool"]:
                 del manifest["tool"]
 
-        return super()._from_dict(manifest, keypath, version)
+        return super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
     def _generate_doc(self, doc,
                       ref_root: str = "",

siliconcompiler/package/https.py

@@ -114,11 +114,16 @@ class HTTPResolver(RemoteResolver):
         except tarfile.ReadError:
             fileobj.seek(0)
             try:
-                with zipfile.ZipFile(fileobj) as zip_ref:
-                    zip_ref.extractall(path=self.cache_path)
-            except zipfile.BadZipFile:
-                raise TypeError(f"Could not extract file from {data_url}. "
-                                "File is not a valid tar.gz or zip archive.")
+                with tarfile.open(fileobj=fileobj, mode='r:bz2') as tar_ref:
+                    tar_ref.extractall(path=self.cache_path)
+            except tarfile.ReadError:
+                fileobj.seek(0)
+                try:
+                    with zipfile.ZipFile(fileobj) as zip_ref:
+                        zip_ref.extractall(path=self.cache_path)
+                except zipfile.BadZipFile:
+                    raise TypeError(f"Could not extract file from {data_url}. "
+                                    "File is not a valid tar.gz or zip archive.")
 
         # --- GitHub-specific directory flattening ---
         # GitHub archives often have a single top-level directory like 'repo-v1.0'.

siliconcompiler/project.py

@@ -5,10 +5,11 @@ import uuid
 
 import os.path
 
-from typing import Union, List, Tuple, TextIO, Optional
+from typing import Union, List, Tuple, TextIO, Optional, Dict, Set
 
 from siliconcompiler.schema import BaseSchema, NamedSchema, EditableSchema, Parameter, Scope, \
-    __version__ as schema_version
+    __version__ as schema_version, \
+    LazyLoad
 
 from siliconcompiler import Design
 from siliconcompiler import Flowgraph
@@ -107,7 +108,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 is not intended for external use."""))
 
         schema.insert("checklist", "default", Checklist())
-        schema.insert("library", BaseSchema())
+        schema.insert("library", _ProjectLibrary())
         schema.insert("flowgraph", "default", Flowgraph())
         schema.insert("metric", MetricSchema())
         schema.insert("record", RecordSchema())
@@ -289,26 +290,11 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         """
         return Project.__name__
 
-    def __populate_deps(self, obj: DependencySchema = None):
-        """
-        Ensures that all loaded dependencies (like libraries) within the project
-        contain correct internal pointers back to the project's libraries.
-        This is crucial for maintaining a consistent and navigable schema graph.
-
-        Args:
-            obj (DependencySchema, optional): An optional dependency object to
-                reset and populate. If None, all existing library dependencies
-                in the project are processed. Defaults to None.
-        """
-        if obj:
-            obj._reset_deps()
-        dep_map = {name: self.get("library", name, field="schema")
-                   for name in self.getkeys("library")}
-        for obj in dep_map.values():
-            if isinstance(obj, DependencySchema):
-                obj._populate_deps(dep_map)
-
-    def _from_dict(self, manifest, keypath, version=None):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
         """
         Populates the project's schema from a dictionary representation.
 
@@ -325,15 +311,13 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Returns:
             Any: The result of the superclass's `_from_dict` method.
         """
-        ret = super()._from_dict(manifest, keypath, version)
-
-        # Restore dependencies
-        self.__populate_deps()
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
 
-        # Preserve logger in history
-        for history in self.getkeys("history"):
-            hist = self.get("history", history, field="schema")
-            hist.__logger = self.__logger
+        if not lazyload.is_enforced:
+            # Preserve logger in history
+            for history in self.getkeys("history"):
+                hist: "Project" = self.get("history", history, field="schema")
+                hist.__logger = self.__logger
 
         return ret
 
@@ -392,7 +376,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
                 self.add_dep(dep)
 
             # Rebuild dependencies to ensure instances are correct
-            self.__populate_deps(obj)
+            self.get("library", field="schema")._populate_deps(obj)
 
     def __import_flow(self, flow: Flowgraph):
         """
@@ -664,6 +648,9 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         # Pass along manager address
         state["__manager__"] = MPManager._get_manager_address()
 
+        # Pass along logger level
+        state["__loglevel__"] = self.logger.level
+
         return state
 
     def __setstate__(self, state):
@@ -676,6 +663,10 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         Args:
             state (dict): The deserialized state of the object.
         """
+        # Retrieve log level
+        loglevel = state["__loglevel__"]
+        del state["__loglevel__"]
+
         # Retrieve manager address
         MPManager._set_manager_address(state["__manager__"])
         del state["__manager__"]
@@ -684,6 +675,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
 
         # Reinitialize logger on restore
         self.__init_logger()
+        self.logger.setLevel(loglevel)
 
         # Restore callbacks
         self.__init_option_callbacks()
@@ -1225,6 +1217,7 @@ class Project(PathSchemaBase, CommandLineSchema, BaseSchema):
         # Setup options:
         for option, value in [
                 ("track", False),
+                ("remote", False),
                 ("hash", False),
                 ("nodisplay", False),
                 ("continue", True),
@@ -1276,3 +1269,61 @@ class Lint(Project):
     @classmethod
     def _getdict_type(cls) -> str:
         return Lint.__name__
+
+
+class _ProjectLibrary(BaseSchema):
+    def _from_dict(self, manifest: Dict,
+                   keypath: Union[List[str], Tuple[str, ...]],
+                   version: Optional[Tuple[int, ...]] = None,
+                   lazyload: LazyLoad = LazyLoad.ON) \
+            -> Tuple[Set[Tuple[str, ...]], Set[Tuple[str, ...]]]:
+        """
+        Populates the project's schema from a dictionary representation.
+
+        This method is typically used during deserialization or when loading
+        a project state from a manifest. After loading the data, it ensures
+        that internal dependencies are correctly re-established.
+
+        Args:
+            manifest (dict): The dictionary containing the schema data.
+            keypath (list): The current keypath being processed (used internally
+                            for recursive loading).
+            version (str, optional): The schema version of the manifest. Defaults to None.
+
+        Returns:
+            Any: The result of the superclass's `_from_dict` method.
+        """
+        ret = super()._from_dict(manifest, keypath, version=version, lazyload=lazyload)
+
+        if not lazyload.is_enforced:
+            # Restore dependencies
+            self._populate_deps(complete=True)
+
+        return ret
+
+    def _populate_deps(self, obj: Optional[DependencySchema] = None, complete: bool = False):
+        """
+        Ensures that all loaded dependencies (like libraries) within the project
+        contain correct internal pointers back to the project's libraries.
+        This is crucial for maintaining a consistent and navigable schema graph.
+
+        Args:
+            obj (DependencySchema, optional): An optional dependency object to
+                reset and populate. If None, all existing library dependencies
+                in the project are processed. Defaults to None.
+            complete (bool, optional): If True, performs a full reset of all
+                DependencySchema objects before populating dependencies. This
+                ensures a clean state during manifest deserialization. Defaults to False.
+        """
+        if obj:
+            obj._reset_deps()
+        dep_map = {name: self.get(name, field="schema") for name in self.getkeys()}
+
+        if complete:
+            for obj in dep_map.values():
+                if isinstance(obj, DependencySchema):
+                    obj._reset_deps()
+
+        for obj in dep_map.values():
+            if isinstance(obj, DependencySchema):
+                obj._populate_deps(dep_map)

siliconcompiler/remote/client.py

@@ -18,7 +18,8 @@ from siliconcompiler import NodeStatus as SCNodeStatus
 from siliconcompiler._metadata import default_server
 from siliconcompiler.flowgraph import RuntimeFlowgraph
 from siliconcompiler.scheduler import Scheduler
-from siliconcompiler.schema import Journal
+from siliconcompiler.schema import Journal, Parameter
+from siliconcompiler.package import PythonPathResolver, FileResolver, KeyPathResolver
 
 from siliconcompiler.utils.logging import get_console_formatter
 from siliconcompiler.utils.curation import collect
@@ -573,19 +574,29 @@ service, provided by SiliconCompiler, is not intended to process proprietary IP.
 
         # Ensure dataroots with python sources are copied
         for key in self.__project.allkeys():
-            key_type = self.__project.get(*key, field='type')
+            if key[0] == "history":
+                continue
+
+            param: Parameter = self.__project.get(*key, field=None)
+            key_type: str = param.get(field="type")
 
             if 'dir' in key_type or 'file' in key_type:
-                for _, step, index in self.__project.get(*key, field=None).getvalues(
-                        return_defvalue=False):
-                    dataroots = self.__project.get(*key, field='dataroot', step=step, index=index)
+                schema_obj = self.__project.get(*key[:-1], field="schema")
+                dataroot_objs = schema_obj._find_files_dataroot_resolvers(True)
+
+                for value, step, index in param.getvalues():
+                    if not value:
+                        continue
+                    dataroots = param.get(field='dataroot', step=step, index=index)
                     if not isinstance(dataroots, list):
                         dataroots = [dataroots]
                     force_copy = False
                     for dataroot in dataroots:
                         if not dataroot:
                             continue
-                        if dataroot.startswith('python://'):
+                        dataroot_resolver = dataroot_objs.get(dataroot, None)
+                        if isinstance(dataroot_resolver,
+                                      (PythonPathResolver, FileResolver, KeyPathResolver)):
                             force_copy = True
                     if force_copy:
                         self.__project.set(*key, True, field='copy', step=step, index=index)

siliconcompiler/scheduler/scheduler.py

@@ -1,5 +1,6 @@
 import io
 import logging
+import multiprocessing
 import os
 import re
 import shutil
@@ -9,7 +10,9 @@ import traceback
 
 import os.path
 
-from typing import Union, Dict, Optional, TYPE_CHECKING
+from datetime import datetime
+
+from typing import Union, Dict, Optional, Tuple, List, TYPE_CHECKING
 
 from siliconcompiler import NodeStatus
 from siliconcompiler.schema import Journal
@@ -18,7 +21,7 @@ from siliconcompiler.scheduler import SchedulerNode
 from siliconcompiler.scheduler import SlurmSchedulerNode
 from siliconcompiler.scheduler import DockerSchedulerNode
 from siliconcompiler.scheduler import TaskScheduler
-from siliconcompiler.scheduler.schedulernode import SchedulerFlowReset
+from siliconcompiler.scheduler.schedulernode import SchedulerFlowReset, SchedulerNodeReset
 from siliconcompiler.tool import TaskExecutableNotFound, TaskExecutableNotReceived
 
 from siliconcompiler import utils
@@ -58,7 +61,7 @@ class Scheduler:
             SCRuntimeError: If the specified flow is not defined or fails validation.
         """
         self.__project = project
-        self.__logger: logging.Logger = project.logger
+        self.__logger: logging.Logger = project.logger.getChild("scheduler")
         self.__name = project.name
 
         flow = self.__project.get("option", "flow")
@@ -97,13 +100,20 @@ class Scheduler:
         self.__record: "RecordSchema" = self.__project.get("record", field="schema")
         self.__metrics: "MetricSchema" = self.__project.get("metric", field="schema")
 
-        self.__tasks = {}
+        self.__tasks: Dict[Tuple[str, str], SchedulerNode] = {}
 
         # Create dummy handler
         self.__joblog_handler = logging.NullHandler()
         self.__org_job_name = self.__project.get("option", "jobname")
         self.__logfile = None
 
+    @property
+    def manifest(self) -> str:
+        """
+        Returns the path to the job manifest
+        """
+        return os.path.join(jobdir(self.__project), f"{self.__name}.pkg.json")
+
     @property
     def log(self) -> Union[None, str]:
         """
@@ -131,7 +141,7 @@ class Scheduler:
         Args:
             header (str): A header message to print before the status list.
         """
-        self.__logger.debug(f"#### {header}")
+        self.__logger.debug(f"#### {header} : {datetime.now().strftime('%H:%M:%S')}")
         for step, index in self.__flow.get_nodes():
             self.__logger.debug(f"({step}, {index}) -> "
                                 f"{self.__record.get('status', step=step, index=index)}")
@@ -284,8 +294,7 @@ class Scheduler:
             self.__project._record_history()
 
             # Record final manifest
-            filepath = os.path.join(jobdir(self.__project), f"{self.__name}.pkg.json")
-            self.__project.write_manifest(filepath)
+            self.__project.write_manifest(self.manifest)
 
             send_messages.send(self.__project, 'summary', None, None)
         finally:
@@ -372,6 +381,8 @@ class Scheduler:
         nodes = self.__flow_runtime.get_nodes()
         error = False
 
+        manifest_name = os.path.basename(self.manifest)
+
         for (step, index) in nodes:
             # Get files we receive from input nodes.
             in_nodes = self.__flow_runtime.get_node_inputs(step, index, record=self.__record)
@@ -396,9 +407,7 @@ class Scheduler:
                         inputs = []
                         continue
 
-                    design = self.__project.get("option", 'design')
-                    manifest = f'{design}.pkg.json'
-                    inputs = [inp for inp in os.listdir(in_step_out_dir) if inp != manifest]
+                    inputs = [inp for inp in os.listdir(in_step_out_dir) if inp != manifest_name]
                 else:
                     in_tool = self.__flow.get(in_step, in_index, "tool")
                     in_task = self.__flow.get(in_step, in_index, "task")
@@ -582,32 +591,23 @@ class Scheduler:
                 with self.__tasks[(step, index)].runtime():
                     self.__tasks[(step, index)].clean_directory()
 
-    def configure_nodes(self) -> None:
-        """
-        Prepare and configure all flow nodes before execution, including loading prior run state,
-        running per-node setup, and marking nodes that require rerun.
+    def __configure_collect_previous_information(self) -> Dict[Tuple[str, str], "Project"]:
+        """Collects information from previous runs for nodes that won't be re-executed.
 
-        This method:
-        - Loads available node manifests from previous jobs and uses them to populate setup data
-          where appropriate.
-        - Runs each node's setup routine to initialize tools and runtime state.
-        - For nodes whose parameters or inputs have changed, marks them and all downstream nodes
-          as pending so they will be re-executed.
-        - Replays preserved journaled results for nodes that remain valid to reuse previous outputs.
-        - On a SchedulerFlowReset, forces a full build-directory recheck and marks every node
-          as pending.
-        - Persists the resulting manifest for the current job before returning.
+        This method identifies nodes that are marked for loading (not cleaning) and
+        are not part of the current 'from' execution path. For each of these
+        nodes, it attempts to load its manifest from a previous run.
+
+        Returns:
+            Dict[Tuple[str, str], "Project"]: A dictionary mapping (step, index)
+                tuples to their corresponding loaded Project objects from
+                previous runs.
         """
         from siliconcompiler import Project
+        self.__print_status("Start - collect")
 
-        from_nodes = []
         extra_setup_nodes = {}
-
-        journal = Journal.access(self.__project)
-        journal.start()
-
-        self.__print_status("Start")
-
+        from_nodes = []
         if self.__project.get('option', 'clean'):
             if self.__project.get("option", "from"):
                 from_nodes = self.__flow_runtime.get_entry_nodes()
@@ -626,16 +626,37 @@ class Scheduler:
                 # Node will be run so no need to load
                 continue
 
-            manifest = os.path.join(workdir(self.__project, step=step, index=index),
-                                    'outputs',
-                                    f'{self.__name}.pkg.json')
+            manifest = self.__tasks[(step, index)].get_manifest()
             if os.path.exists(manifest):
                 # ensure we setup these nodes again
                 try:
                     extra_setup_nodes[(step, index)] = Project.from_manifest(filepath=manifest)
-                except Exception:
+                except Exception as e:
+                    self.__logger.debug(f"Reading {manifest} caused: {e}")
                     pass
 
+        self.__print_status("End - collect")
+
+        return extra_setup_nodes
+
+    def __configure_run_setup(self, extra_setup_nodes: Dict[Tuple[str, str], "Project"]) -> None:
+        """Runs the setup() method for all flow nodes and forwards previous status.
+
+        This method iterates through all nodes in execution order and calls
+        their respective `setup()` methods.
+
+        It also uses the `extra_setup_nodes` to:
+        1. Prune nodes from `extra_setup_nodes` if their `setup()` method
+           returns False (indicating the node is no longer valid).
+        2. Forward the 'status' from a valid, previously-run node (found in
+           `extra_setup_nodes`) into the current job's records.
+
+        Args:
+            extra_setup_nodes (Dict[Tuple[str, str], "Project"]): A dictionary
+                of loaded Project objects from previous runs. This dictionary
+                may be modified in-place (nodes may be removed).
+        """
+        self.__print_status("Start - setup")
         # Setup tools for all nodes to run
         for layer_nodes in self.__flow.get_execution_order():
             for step, index in layer_nodes:
@@ -655,28 +676,155 @@ class Scheduler:
                     if node_status:
                         # Forward old status
                         self.__record.set('status', node_status, step=step, index=index)
+        self.__print_status("End - setup")
+
+    @staticmethod
+    def _configure_run_required(task: SchedulerNode) \
+            -> Optional[Union[SchedulerFlowReset, SchedulerNodeReset]]:
+        """
+        Helper method to run requires_run() with threads.
+        """
+        with task.runtime():
+            try:
+                task.requires_run()
+            except (SchedulerFlowReset, SchedulerNodeReset) as e:
+                return e
+        return None
+
+    def __configure_check_run_required(self) -> List[Tuple[str, str]]:
+        """Checks which nodes require a re-run and which can be replayed.
 
-        self.__print_status("After setup")
+        This method iterates through all nodes that are currently marked as
+        'SUCCESS' (typically from a previous run). It calls `requires_run()`
+        on each to determine if inputs, parameters, or other dependencies
+        have changed.
+
+        - If `requires_run()` is True, the node is marked as 'pending' (and
+          will be re-executed).
+        - If `requires_run()` is False, the node is added to the 'replay' list,
+          indicating its previous results can be reused.
+
+        Returns:
+            List[Tuple[str, str]]: A list of (step, index) tuples for nodes
+                that do *not* require a re-run and whose results can be
+                replayed from the journal.
+        """
+        self.__print_status("Start - check")
+
+        replay: List[Tuple[str, str]] = []
+
+        nodes: List[Tuple[str, str]] = []
+
+        def filter_nodes(nodes: List[Tuple[str, str]]) -> None:
+            for step, index in tuple(nodes):
+                # Only look at successful nodes
+                if self.__record.get("status", step=step, index=index) != NodeStatus.SUCCESS:
+                    nodes.remove((step, index))
+
+        def create_node_group(nodes: List[Tuple[str, str]], size: int) -> List[Tuple[str, str]]:
+            group = []
+            for _ in range(size):
+                if nodes:
+                    group.append(nodes.pop(0))
+            return group
+
+        # Collect initial list of nodes to process
+        for layer_nodes in self.__flow.get_execution_order():
+            nodes.extend(layer_nodes)
+
+        # Determine pool size
+        cores = utils.get_cores()
+        pool_size = self.project.option.scheduler.get_maxthreads() or cores
+        pool_size = max(1, min(cores, pool_size))
+
+        # Limit based on number of nodes if less than number of cores
+        filter_nodes(nodes)
+        if not nodes:
+            # No nodes left so just return
+            return []
+
+        pool_size = min(pool_size, len(nodes))
+
+        self.__logger.debug(f"Check pool size: {pool_size}")
+
+        # Call this in case this was invoked without __main__
+        multiprocessing.freeze_support()
+
+        with multiprocessing.get_context("spawn").Pool(pool_size) as pool:
+            while True:
+                # Filter nodes
+                filter_nodes(nodes)
+
+                # Generate a group of nodes to run
+                group = create_node_group(nodes, pool_size)
+                self.__logger.debug(f"Group to check: {group}")
+                if not group:
+                    # Group is empty
+                    break
+
+                tasks = [self.__tasks[(step, index)] for step, index in group]
+                # Suppress excess info messages during checks
+                cur_level = self.project.logger.level
+                self.project.logger.setLevel(logging.WARNING)
+                try:
+                    runcheck = pool.map(Scheduler._configure_run_required, tasks)
+                finally:
+                    self.project.logger.setLevel(cur_level)
+
+                for node, runrequired in zip(group, runcheck):
+                    if self.__record.get("status", step=node[0], index=node[1]) != \
+                            NodeStatus.SUCCESS:
+                        continue
+
+                    self.__logger.debug(f"  Result: {node} -> {runrequired}")
+
+                    if runrequired is not None:
+                        runrequired.log(self.__logger)
+
+                        if isinstance(runrequired, SchedulerFlowReset):
+                            raise runrequired from None
+
+                        # This node must be run
+                        self.__mark_pending(*node)
+                    else:
+                        # import old information
+                        replay.append(node)
+
+        self.__print_status("End - check")
+
+        return replay
+
+    def configure_nodes(self) -> None:
+        """
+        Prepare and configure all flow nodes before execution, including loading prior run state,
+        running per-node setup, and marking nodes that require rerun.
+
+        This method:
+        - Loads available node manifests from previous jobs and uses them to populate setup data
+          where appropriate.
+        - Runs each node's setup routine to initialize tools and runtime state.
+        - For nodes whose parameters or inputs have changed, marks them and all downstream nodes
+          as pending so they will be re-executed.
+        - Replays preserved journaled results for nodes that remain valid to reuse previous outputs.
+        - On a SchedulerFlowReset, forces a full build-directory recheck and marks every node
+          as pending.
+        - Persists the resulting manifest for the current job before returning.
+        """
+        journal = Journal.access(self.__project)
+        journal.start()
+
+        extra_setup_nodes = self.__configure_collect_previous_information()
+
+        self.__configure_run_setup(extra_setup_nodes)
 
         # Check for modified information
         try:
-            replay = []
-            for layer_nodes in self.__flow.get_execution_order():
-                for step, index in layer_nodes:
-                    # Only look at successful nodes
-                    if self.__record.get("status", step=step, index=index) != NodeStatus.SUCCESS:
-                        continue
+            replay = self.__configure_check_run_required()
 
-                    with self.__tasks[(step, index)].runtime():
-                        if self.__tasks[(step, index)].requires_run():
-                            # This node must be run
-                            self.__mark_pending(step, index)
-                        elif (step, index) in extra_setup_nodes:
-                            # import old information
-                            replay.append((step, index))
             # Replay previous information
             for step, index in replay:
-                Journal.access(extra_setup_nodes[(step, index)]).replay(self.__project)
+                if (step, index) in extra_setup_nodes:
+                    Journal.access(extra_setup_nodes[(step, index)]).replay(self.__project)
         except SchedulerFlowReset:
             # Mark all nodes as pending
             self.__clean_build_dir_full(recheck=True)
@@ -684,7 +832,7 @@ class Scheduler:
             for step, index in self.__flow.get_nodes():
                 self.__mark_pending(step, index)
 
-        self.__print_status("After requires run")
+        self.__print_status("Before ensure")
 
         # Ensure all nodes are marked as pending if needed
         for layer_nodes in self.__flow_runtime.get_execution_order():
@@ -693,11 +841,12 @@ class Scheduler:
                 if NodeStatus.is_waiting(status) or NodeStatus.is_error(status):
                     self.__mark_pending(step, index)
 
-        self.__print_status("After ensure")
+        self.__print_status("FINAL")
+
+        # Write configured manifest
+        os.makedirs(os.path.dirname(self.manifest), exist_ok=True)
+        self.__project.write_manifest(self.manifest)
 
-        os.makedirs(jobdir(self.__project), exist_ok=True)
-        self.__project.write_manifest(os.path.join(jobdir(self.__project),
-                                                   f"{self.__name}.pkg.json"))
         journal.stop()
 
     def __check_display(self) -> None: