solver-support 0.4.0__tar.gz → 0.4.1__tar.gz

{solver_support-0.4.0/solver_support.egg-info → solver_support-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.4.0
+Version: 0.4.1
 Summary: Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline
 Author: András Salamon
 License-Expression: BSD-3-Clause
@@ -75,7 +75,7 @@ runtime dependencies are `psutil` and `PyYAML`.
 ## Quick start
 
 The package ships no model registry, but it carries a commented starter one
-(Fast Downward, SymK, ENHSP and Savile Row) to copy and edit. Writing it out
+(Conjure, Savile Row, Fast Downward, SymK and ENHSP) to copy and edit. Writing it out
 does not wire it; you point the registry at it:
 
 ```python

{solver_support-0.4.0 → solver_support-0.4.1}/README.md

@@ -47,7 +47,7 @@ runtime dependencies are `psutil` and `PyYAML`.
 ## Quick start
 
 The package ships no model registry, but it carries a commented starter one
-(Fast Downward, SymK, ENHSP and Savile Row) to copy and edit. Writing it out
+(Conjure, Savile Row, Fast Downward, SymK and ENHSP) to copy and edit. Writing it out
 does not wire it; you point the registry at it:
 
 ```python

{solver_support-0.4.0 → solver_support-0.4.1}/docs/timing-model.md

@@ -70,6 +70,18 @@ fields. All times are seconds unless noted.
 ### Savile Row (Conjure / Essence Prime models)
 
 - **Shape**: a horizon scan — one `solving-horizon-N` phase per move budget.
+  Each horizon reaches the model as `letting <name> be N`, appended to the
+  instance for every name in the model's `horizon-params` (or its solver's).
+  These must be exactly the parameters the model declares, since Conjure
+  rejects a `letting` for one it lacks. A config without the key gets the
+  historical names, `noSteps` (Savile Row) or `maxMoves` + `horizon` (Conjure),
+  so models written for those keep working. Only `letting` lines for those names
+  are dropped from the instance first, not any line that mentions one.
+- **Which Savile Row entry**: Conjure only refines and translates. Each horizon
+  is tailored and solved by the Savile Row entry the `conjure` config names
+  (`savilerow: <entry>`), and an Essence run's `--tune` picks among that
+  entry's presets. A direct Savile Row scan uses the run's own solver. Without
+  either, it is `kissat`, the name older configs use.
 - **Split source**: Savile Row writes `<param>.info` per horizon;
   `_record_savilerow_times` (`solver_horizon.py`) reads `SavileRowTotalTime`
   (tailoring) → `savilerow_time` and `SolverTotalTime` (backend search) →
@@ -176,6 +188,14 @@ So size the external kill with `savilerow_backstop(T, S)` — `T + S` plus grace
 for the flush — and it comes to mean "the toolchain ignored its limits", a
 genuine fault rather than an ordinary and lossy way for a run to end.
 
+The built-in horizon scans do this per horizon when asked:
+`SavileRowSolver.solve(..., backstop=True)` and `ConjureSolver.solve(...,
+backstop=True)` kill each horizon at `savilerow_backstop(R)`, where `R` is the
+budget that horizon's command was built with. Without it, each horizon is
+killed at the runner's own timeout, as before. It is opt-in because a scan
+killed at the backstop can overrun the runner's timeout by up to about that
+timeout again, which would change the run times of an existing consumer.
+
 **To hold a run to a wall-clock budget, shrink the pair, not the backstop.**
 Give the solver `S = T - (what tailoring will cost)`. The core picks no reserve
 policy: a horizon scan can estimate from the previous horizon's

{solver_support-0.4.0 → solver_support-0.4.1}/pyproject.toml

@@ -20,7 +20,7 @@ name = "solver-support"
 # escape hatch for a version that genuinely cannot be known without building.
 # Ours can. Carrying a `.devN` suffix between releases keeps the working tree
 # from claiming a version that is already tagged and published.
-version = "0.4.0"
+version = "0.4.1"
 description = "Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline"
 readme = "README.md"
 requires-python = ">=3.9"

{solver_support-0.4.0 → solver_support-0.4.1}/solver_support/horizon_utils.py

@@ -6,10 +6,11 @@ that can be used by different solver types (Savile Row, Conjure, etc.).
 """
 
 import logging
+import re
 import shutil
 import time
 from pathlib import Path
-from typing import Optional, Callable, Tuple
+from typing import Optional, Callable, Sequence, Tuple
 
 from .file_management import SolutionFileNamer
 from .global_state import global_state
@@ -76,6 +77,20 @@ def _create_main_solution_from_best(runner: SolverRunner, best_solution_found: P
     return main_solution
 
 
+#: Every name a horizon scan has ever written, for a caller that does not say
+#: which it writes. Only `letting` lines for these are dropped from the instance;
+#: the scan's callback then appends its own for the horizon at hand.
+LEGACY_HORIZON_PARAMS = ('noSteps', 'maxMoves', 'horizon')
+
+_LETTING_NAME_RE = re.compile(r'^\s*letting\s+(\w+)\b')
+
+
+def _is_horizon_letting(line: str, names: Sequence[str]) -> bool:
+    """Whether ``line`` sets one of the horizon parameters ``names``."""
+    m = _LETTING_NAME_RE.match(line)
+    return bool(m) and m.group(1) in names
+
+
 def horizon_search(runner: SolverRunner,
                    param_file: Path,
                    startat: int,
@@ -83,7 +98,8 @@ def horizon_search(runner: SolverRunner,
                    logger: logging.Logger,
                    min_horizon: int = 1,
                    stopat: int = 100,
-                   extra_constraints_callback: Optional[Callable[[Path, int], None]] = None) -> Optional[Path]:
+                   extra_constraints_callback: Optional[Callable[[Path, int], None]] = None,
+                   horizon_params: Optional[Sequence[str]] = None) -> Optional[Path]:
     """
     Generic horizon-extending search loop.
 
@@ -97,6 +113,9 @@ def horizon_search(runner: SolverRunner,
         min_horizon: Minimum allowed horizon value
         stopat: Highest horizon to try (inclusive upper limit of the scan)
         extra_constraints_callback: Optional function(horizon_param_file, n) to add extra constraints
+        horizon_params: The parameter names the callback sets to the horizon, so
+            an instance's own value for them is dropped first. None means
+            LEGACY_HORIZON_PARAMS.
 
     Returns:
         Path to solution file if found, None otherwise
@@ -137,7 +156,8 @@ def horizon_search(runner: SolverRunner,
             return None
         
         # Create parameter file with horizon constraints
-        horizon_param_file = create_horizon_param_file(param_file, output_dir, n, logger, runner)
+        horizon_param_file = create_horizon_param_file(
+            param_file, output_dir, n, logger, runner, horizon_params=horizon_params)
         if not horizon_param_file:
             continue
             
@@ -200,7 +220,8 @@ def horizon_search(runner: SolverRunner,
     return None
 
 
-def create_horizon_param_file(param_file: Path, output_dir: Path, n: int, logger: logging.Logger, runner: SolverRunner = None) -> Optional[Path]:
+def create_horizon_param_file(param_file: Path, output_dir: Path, n: int, logger: logging.Logger, runner: SolverRunner = None,
+                              horizon_params: Optional[Sequence[str]] = None) -> Optional[Path]:
     """
     Create parameter file with base content, ready for horizon-specific constraints.
     
@@ -210,6 +231,9 @@ def create_horizon_param_file(param_file: Path, output_dir: Path, n: int, logger
         n: Horizon value
         logger: Logger instance
         runner: SolverRunner instance for consistent naming (optional for backward compatibility)
+        horizon_params: Names whose `letting` lines are dropped from the
+            instance, since the caller sets them per horizon. None means
+            LEGACY_HORIZON_PARAMS.
         
     Returns:
         Path to created parameter file, or None if creation failed
@@ -233,12 +257,13 @@ def create_horizon_param_file(param_file: Path, output_dir: Path, n: int, logger
         with open(param_file, 'r') as f:
             param_content = f.read()
         
-        # Remove any existing horizon-related lines
-        param_lines = []
-        for line in param_content.splitlines():
-            # Remove existing horizon constraint lines
-            if not any(keyword in line for keyword in ['noSteps', 'maxMoves', 'horizon']):
-                param_lines.append(line)
+        # Drop the instance's own value for each horizon parameter: the caller
+        # appends one per horizon, and two lettings of a name is an error. Only
+        # a `letting` of exactly that name goes - a line that merely mentions
+        # it (a comment, `letting horizonLimit`) is the instance's own.
+        names = LEGACY_HORIZON_PARAMS if horizon_params is None else tuple(horizon_params)
+        param_lines = [line for line in param_content.splitlines()
+                       if not _is_horizon_letting(line, names)]
         
         # Write base parameter file
         with open(horizon_param_file, 'w') as f:

{solver_support-0.4.0 → solver_support-0.4.1}/solver_support/model_registry.py

@@ -8,12 +8,20 @@ from the original bash run script.
 """
 
 from pathlib import Path
-from typing import Dict, Any, Optional, List, Tuple, Callable
+from typing import Dict, Any, Optional, List, Tuple, Callable, Sequence
 import copy
+import os
 import shutil
 import yaml
 
 
+#: The Savile Row entry a Conjure solver delegates to when its config does not
+#: name one (``savilerow:``), and the entry a Savile Row horizon scan uses when
+#: neither the caller nor the run names one. Kept for configs written before
+#: those could be named; a new config should name its own.
+LEGACY_CONJURE_SAVILEROW = 'kissat'
+
+
 class ModelRegistryError(Exception):
     """Exception raised for model registry errors."""
     pass
@@ -43,10 +51,13 @@ _user_config_finder: Optional[Callable[[], Optional[Path]]] = None
 def set_default_config_path(path) -> None:
     """Register the default ``models.yaml`` the registry loads at startup.
 
-    Stored as-is (a path or an ``importlib.resources`` traversable), so the
-    loader can ``open`` it directly regardless of how the consumer resolved it.
+    A ``str`` or other path-like becomes a :class:`~pathlib.Path`; anything
+    else (an ``importlib.resources`` traversable) is stored as-is, so the loader
+    can ``open`` it directly regardless of how the consumer resolved it.
     """
     global _default_config_path
+    if isinstance(path, (str, os.PathLike)):
+        path = Path(path)
     _default_config_path = path
 
 
@@ -89,9 +100,15 @@ class ModelRegistry(CommandBuilderMixin):
         # First, load the default YAML config from package
         default_yaml = self._find_default_yaml_config()
         if not default_yaml:
+            if _default_config_path is not None:
+                raise ModelRegistryError(
+                    f"The registered models.yaml ({_default_config_path}) is not "
+                    "a file."
+                )
             raise ModelRegistryError(
-                "Default models.yaml configuration file not found. "
-                "Please ensure the package is properly installed."
+                "No models.yaml is registered: solver-support ships without one. "
+                "Call set_default_config_path() before first use; "
+                "write_starter_config() writes a starter to begin from."
             )
         
         self.config = {'models': {}, 'solvers': {}}
@@ -642,6 +659,33 @@ class ModelRegistry(CommandBuilderMixin):
             return None, None
         return model_config.get('status'), model_config.get('status-detail')
 
+    def get_horizon_params(self, model_type: str,
+                           default: Sequence[str] = ()) -> List[str]:
+        """The parameter names a horizon scan sets to the horizon for a model.
+
+        Each horizon N reaches the model as ``letting <name> be N`` appended to
+        the instance, so these must be exactly the names the model declares:
+        Conjure rejects a ``letting`` for a parameter the model does not have.
+        Read from the model's ``horizon-params``, then its solver's, then
+        ``default`` - the route's own historical names, which configs written
+        before the key existed rely on. A single name may be given as a string.
+        Resolves aliases and never raises (an unknown model gets ``default``).
+        """
+        try:
+            _, model_config = self.resolve_model_variant(model_type)
+        except (ValueError, ModelRegistryError):
+            return list(default)
+        names = model_config.get('horizon-params')
+        if names is None:
+            try:
+                names = self.get_solver_config(
+                    model_config.get('solver', '')).get('horizon-params')
+            except ModelRegistryError:
+                names = None
+        if names is None:
+            return list(default)
+        return [names] if isinstance(names, str) else list(names)
+
     def get_model_default_tune(self, model_type: str) -> Optional[str]:
         """Return a model's preferred ``--tune`` preset, or None.
 
@@ -656,17 +700,29 @@ class ModelRegistry(CommandBuilderMixin):
             return None
         return model_config.get('tune')
 
+    def get_conjure_savilerow(self, solver_name: str = 'conjure') -> str:
+        """The Savile Row entry a Conjure solver hands each horizon's solve to.
+
+        Conjure only refines and translates. Savile Row then tailors the
+        instance and runs its backend, under the solver entry the ``conjure``
+        config names with ``savilerow:``. A config without the key gets
+        ``kissat``, the name configs written before the key existed use.
+        """
+        return self.get_solver_config(solver_name).get(
+            'savilerow', LEGACY_CONJURE_SAVILEROW)
+
     def get_tune_backend(self, solver_name: str) -> str:
         """Return the backend whose tune presets govern ``--tune`` for a solver.
 
         Almost always the solver itself. The exception is the Conjure/Essence
-        path: its per-horizon inner solve is delegated to kissat (see
-        ConjureSolver), so an Essence run's ``--tune`` presets are kissat's, not
-        the tune-less ``conjure`` entry's. Keeping this mapping here means the
-        CLI validity check and ``build_*_command`` agree on what a tune means.
+        path: its per-horizon inner solve is delegated to a Savile Row entry
+        (:meth:`get_conjure_savilerow`), so an Essence run's ``--tune`` presets
+        are that entry's, not the tune-less ``conjure`` entry's. Keeping this
+        mapping here means the CLI validity check and ``build_*_command`` agree
+        on what a tune means.
         """
         if self.get_solver_type(solver_name) == 'conjure':
-            return 'kissat'
+            return self.get_conjure_savilerow(solver_name)
         return solver_name
 
     def get_valid_tunes(self, solver_name: str) -> List[str]:
@@ -828,8 +884,8 @@ class ModelRegistry(CommandBuilderMixin):
 def starter_config_text() -> str:
     """The starter ``models.yaml`` shipped with the package, as text.
 
-    A commented example registry - Fast Downward, SymK, ENHSP and Savile Row -
-    for a new user to copy and edit. It is never loaded implicitly: the core
+    A commented example registry - Conjure, Savile Row, Fast Downward, SymK
+    and ENHSP - for a new user to copy and edit. It is never loaded implicitly: the core
     still ships unwired, and :class:`ModelRegistry` still raises until a config
     path is set. Unlike :meth:`ModelRegistry.dump_config` it keeps its comments,
     which is what makes it fit to start from.

{solver_support-0.4.0 → solver_support-0.4.1}/solver_support/solver_horizon.py

@@ -10,7 +10,7 @@ import os
 import shutil
 import time
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, List, Tuple
 
 from .solver_stats import SolverStatsExtractor
 from .solver_runner import SolverExecutableError
@@ -18,19 +18,90 @@ from .global_state import global_state
 from .file_management import SolutionFileNamer, ObjectiveFileManager
 from .solver_base import Solver
 from .horizon_utils import horizon_search, calculate_horizon_timeout
+from .command_builders import savilerow_backstop
 from .objective import raw_objective_from_solution
+from .model_registry import LEGACY_CONJURE_SAVILEROW
 
 
 class HorizonBasedSolver(Solver):
     """Base class for solvers that use horizon search with optimization support."""
 
-    def __init__(self, solver_runner, solver_name: str = 'kissat'):
-        """Initialize with solver runner and optimization tracking."""
+    #: The parameter(s) this route sets to the horizon, for a model whose
+    #: registry entry names none (``horizon-params``). Kept for configs written
+    #: before the key existed; a new config should name its own.
+    DEFAULT_HORIZON_PARAMS: Tuple[str, ...] = ()
+
+    def __init__(self, solver_runner, solver_name: Optional[str] = None):
+        """Initialize with solver runner and optimization tracking.
+
+        ``solver_name`` is the Savile Row entry that solves each horizon. None
+        resolves it from the registry when first needed (see
+        :meth:`_default_solver_name`).
+        """
         super().__init__(solver_runner)
         self._best_objective = None
         self._has_timeout = False  # Track if we're running with a timeout
         self._stop_at_first = False  # regime: first stops the scan at the first solving horizon
-        self.solver_name = solver_name  # the backend config (kissat/minion/...)
+        self._solver_name = solver_name
+        self._backstop = False  # size each horizon's kill above its in-band limits
+
+    @property
+    def solver_name(self) -> str:
+        """The Savile Row entry that solves each horizon."""
+        if self._solver_name is None:
+            return self._default_solver_name()
+        return self._solver_name
+
+    @solver_name.setter
+    def solver_name(self, value: Optional[str]) -> None:
+        self._solver_name = value
+
+    def _default_solver_name(self) -> str:
+        """The entry to use when the caller named none: the run's own solver
+        if it is a Savile Row entry, else the legacy name."""
+        try:
+            run_solver = self.runner.summary.solver
+            if global_state.model_registry.get_solver_type(run_solver) == 'savilerow':
+                return run_solver
+        except Exception:
+            pass
+        return LEGACY_CONJURE_SAVILEROW
+
+    def _horizon_params(self) -> List[str]:
+        """The parameter names this run sets to the horizon (see
+        :meth:`ModelRegistry.get_horizon_params`)."""
+        try:
+            return global_state.model_registry.get_horizon_params(
+                self.runner.summary.model, self.DEFAULT_HORIZON_PARAMS)
+        except Exception:
+            return list(self.DEFAULT_HORIZON_PARAMS)
+
+    def _horizon_watchdog(self, horizon_timeout: Optional[int]) -> Optional[int]:
+        """The kill for one horizon's Savile Row run, or None for the runner's.
+
+        With ``backstop=True`` it is :func:`savilerow_backstop` over the same
+        budget the command was built with: Savile Row's ``-timelimit`` and the
+        solver's own limit each get ``horizon_timeout`` and run one after the
+        other, so a kill below their sum can land before Savile Row writes its
+        ``.info`` and loses every statistic. Off by default, because a scan
+        killed at the backstop can overrun the runner's timeout by up to about
+        that timeout again.
+        """
+        if self._backstop and horizon_timeout is not None:
+            return savilerow_backstop(horizon_timeout)
+        return None
+
+    def _write_horizon(self, horizon_param_file: Path, n: int,
+                       names: List[str]) -> bool:
+        """Append ``letting <name> be n`` for each horizon parameter."""
+        try:
+            with open(horizon_param_file, 'a') as f:
+                for name in names:
+                    f.write(f"letting {name} be {n}\n")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to add horizon constraints: {e}")
+            return False
 
     def _generate_objective_file_path(self, n: int) -> Optional[Path]:
         """Generate the objective file path for a given horizon, or None.
@@ -339,7 +410,9 @@ class HorizonBasedSolver(Solver):
 class SavileRowSolver(HorizonBasedSolver):
     """Solver implementation for Savile Row with horizon search."""
 
-    def __init__(self, solver_runner, solver_name: str = 'kissat'):
+    DEFAULT_HORIZON_PARAMS = ('noSteps',)
+
+    def __init__(self, solver_runner, solver_name: Optional[str] = None):
         """Initialize with solver runner and solver name."""
         super().__init__(solver_runner, solver_name)
 
@@ -352,6 +425,10 @@ class SavileRowSolver(HorizonBasedSolver):
                 - model_path: Path to Essence Prime model file (required)
                 - startat: Starting horizon value (default: 1)
                 - stopat: Highest horizon to try (default: 100)
+                - backstop: kill each horizon at savilerow_backstop of its
+                  budget rather than at the runner's timeout, so Savile Row's
+                  own limits fire first and its statistics survive
+                  (default: False)
                 - objbound: Objective bound constraint for optimization models
         Returns:
             Path to solution file if successful, None otherwise
@@ -363,6 +440,7 @@ class SavileRowSolver(HorizonBasedSolver):
 
         startat = kwargs.get('startat', 1)
         stopat = kwargs.get('stopat', 100)
+        self._backstop = bool(kwargs.get('backstop', False))
         objbound = kwargs.get('objbound')
 
         # Setup optimization parameters
@@ -372,6 +450,7 @@ class SavileRowSolver(HorizonBasedSolver):
         # Track total elapsed time for timeout management
         total_start_time = time.time()
         original_timeout = self.runner.timeout
+        horizon_params = self._horizon_params()
 
         def savilerow_horizon_callback(n: int, horizon_param_file: Path) -> Optional[Path]:
             """Execute Savile Row for a specific horizon."""
@@ -386,12 +465,7 @@ class SavileRowSolver(HorizonBasedSolver):
                 # Remove any existing objective file before this horizon run
                 self._prepare_objective_file(obj_file)
 
-            # Add Savile Row specific constraint
-            try:
-                with open(horizon_param_file, 'a') as f:
-                    f.write(f"letting noSteps be {n}\n")
-            except Exception as e:
-                self.logger.error(f"Failed to add noSteps constraint: {e}")
+            if not self._write_horizon(horizon_param_file, n, horizon_params):
                 return None
 
             # Build Savile Row command for this horizon using helper method
@@ -407,7 +481,8 @@ class SavileRowSolver(HorizonBasedSolver):
                 f"solving-horizon-{n}",
                 savilerow_cmd,
                 expected_outputs=[str(expected_solution)],
-                horizon_number=n
+                horizon_number=n,
+                timeout=self._horizon_watchdog(horizon_timeout)
             )
 
             # Record Savile Row's tailoring vs solver time split from the .info
@@ -454,13 +529,24 @@ class SavileRowSolver(HorizonBasedSolver):
         return horizon_search(
             self.runner, param_file, startat, savilerow_horizon_callback, self.logger,
             stopat=stopat,
-            extra_constraints_callback=self._add_objective_constraint if (is_opt_model and continue_scan) else None
+            extra_constraints_callback=self._add_objective_constraint if (is_opt_model and continue_scan) else None,
+            horizon_params=horizon_params
         )
 
 
 class ConjureSolver(HorizonBasedSolver):
     """Solver implementation for Conjure (Essence to EPrime to solution)."""
 
+    DEFAULT_HORIZON_PARAMS = ('maxMoves', 'horizon')
+
+    def _default_solver_name(self) -> str:
+        """The Savile Row entry the ``conjure`` config names, else the legacy
+        name (see :meth:`ModelRegistry.get_conjure_savilerow`)."""
+        try:
+            return global_state.model_registry.get_conjure_savilerow()
+        except Exception:
+            return LEGACY_CONJURE_SAVILEROW
+
     def solve(self, param_file: Path, **kwargs) -> Optional[Path]:
         """
         Execute Conjure solver with horizon search loop for Essence models.
@@ -470,6 +556,10 @@ class ConjureSolver(HorizonBasedSolver):
                 - model_path: Path to Essence model file (required)
                 - startat: Starting horizon value (default: 1)
                 - stopat: Highest horizon to try (default: 100)
+                - backstop: kill each horizon at savilerow_backstop of its
+                  budget rather than at the runner's timeout, so Savile Row's
+                  own limits fire first and its statistics survive
+                  (default: False)
         Returns:
             Path to solution file if successful, None otherwise
         """
@@ -480,6 +570,7 @@ class ConjureSolver(HorizonBasedSolver):
 
         startat = kwargs.get('startat', 1)
         stopat = kwargs.get('stopat', 100)
+        self._backstop = bool(kwargs.get('backstop', False))
 
         # Step 1: Modelling - create EPrime from Essence
         epm_path = self._do_conjure_modelling(str(model_path))
@@ -493,19 +584,14 @@ class ConjureSolver(HorizonBasedSolver):
         # Track total elapsed time for timeout management
         total_start_time = time.time()
         original_timeout = self.runner.timeout
+        horizon_params = self._horizon_params()
 
         def conjure_horizon_callback(n: int, horizon_param_file: Path) -> Optional[Path]:
             """Execute Conjure solve and translate for a specific horizon."""
             # Calculate remaining timeout for this horizon step
             horizon_timeout = calculate_horizon_timeout(total_start_time, original_timeout, n, self.logger)
 
-            # Add Conjure specific constraints
-            try:
-                with open(horizon_param_file, 'a') as f:
-                    f.write(f"letting maxMoves be {n}\n")
-                    f.write(f"letting horizon be {n}\n")
-            except Exception as e:
-                self.logger.error(f"Failed to add horizon constraints: {e}")
+            if not self._write_horizon(horizon_param_file, n, horizon_params):
                 return None
 
             # Execute the solve and translate pipeline
@@ -541,7 +627,8 @@ class ConjureSolver(HorizonBasedSolver):
             self.runner, param_file, startat, conjure_horizon_callback, self.logger,
             min_horizon=2,
             stopat=stopat,
-            extra_constraints_callback=self._add_objective_constraint if (is_opt_model and continue_scan) else None
+            extra_constraints_callback=self._add_objective_constraint if (is_opt_model and continue_scan) else None,
+            horizon_params=horizon_params
         )
 
     def _do_conjure_modelling(self, model_path: str) -> Optional[Path]:
@@ -629,7 +716,8 @@ class ConjureSolver(HorizonBasedSolver):
             f"solving-horizon-{n}",
             savilerow_cmd,
             expected_outputs=[str(eps_file)],
-            horizon_number=n
+            horizon_number=n,
+            timeout=self._horizon_watchdog(horizon_timeout)
         )
 
         # Record Savile Row's tailoring vs solver time split. Here Savile Row is