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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.4.0
+Version: 0.4.2
 Summary: Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline
 Author: András Salamon
 License-Expression: BSD-3-Clause
@@ -37,6 +37,24 @@ subprocesses with timeouts and clean teardown, naming the per-run files, parsing
 solver output into a uniform timing / cost-layer model, and driving the horizon
 (increasing-difficulty) loop.
 
+Its main value is a **unified semantics for solver behaviour**. Each solver
+reports how a run ended in its own way, and the raw signals are misleading
+taken at face value:
+
+- Fast Downward's exit 12 can mean a proof, a time limit or a search that gave up.
+- ENHSP exits 0 after a proof and after failing to read its input alike.
+- Savile Row prints the same "no solution" whether the backend refuted the
+  instance or stopped at its own limit.
+- A SAT solver's 10 and 20 are answers, not failures.
+
+solver-support reads each solver's exit codes, logs and info files. It reports
+every run in one vocabulary: a `verdict` (`sat` / `unsat` / `unknown` / `error` /
+`killed`, with a reason) for each solve, and an `outcome` and `stop_reason` for
+the run. So `unsat` means a proof, whichever solver produced it. A run that
+merely found nothing, or crashed, never reads as one. The rules for each solver
+are checked against its source and its real output, and are documented in
+[`timing-model.md`](https://github.com/ott2/solver-support/blob/main/docs/timing-model.md).
+
 It carries **no** notion of any particular problem domain or objective. A
 consumer supplies:
 
@@ -75,7 +93,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.2}/README.md

@@ -9,6 +9,24 @@ subprocesses with timeouts and clean teardown, naming the per-run files, parsing
 solver output into a uniform timing / cost-layer model, and driving the horizon
 (increasing-difficulty) loop.
 
+Its main value is a **unified semantics for solver behaviour**. Each solver
+reports how a run ended in its own way, and the raw signals are misleading
+taken at face value:
+
+- Fast Downward's exit 12 can mean a proof, a time limit or a search that gave up.
+- ENHSP exits 0 after a proof and after failing to read its input alike.
+- Savile Row prints the same "no solution" whether the backend refuted the
+  instance or stopped at its own limit.
+- A SAT solver's 10 and 20 are answers, not failures.
+
+solver-support reads each solver's exit codes, logs and info files. It reports
+every run in one vocabulary: a `verdict` (`sat` / `unsat` / `unknown` / `error` /
+`killed`, with a reason) for each solve, and an `outcome` and `stop_reason` for
+the run. So `unsat` means a proof, whichever solver produced it. A run that
+merely found nothing, or crashed, never reads as one. The rules for each solver
+are checked against its source and its real output, and are documented in
+[`timing-model.md`](https://github.com/ott2/solver-support/blob/main/docs/timing-model.md).
+
 It carries **no** notion of any particular problem domain or objective. A
 consumer supplies:
 
@@ -47,7 +65,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.2}/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
@@ -276,9 +296,13 @@ where the code is ambiguous, into the same vocabulary as the Savile Row verdict.
 
 - `Time limit reached. Abort search.` (the search's `max_time=`) gives
   `search-limit`.
-- `Completely explored state space -- no solution!` gives `unsat`/`exhausted`,
-  or `bounded` if the `--search` string has a `bound=`. The log looks the same
-  either way, so the argv is read for it. The translator's
+- `Completely explored state space -- no solution!` gives `unsat`/`exhausted`.
+  It gives `bounded` instead if the search has a `bound=`, and
+  `unsafe-pruning` if an evaluator's dead ends are unreliable on this task
+  (below). The exhaustion line looks the same either way, so the search is read
+  from the driver's `search command line string`. That line has aliases
+  expanded and `--evaluator` predefinitions included. If the line is missing,
+  the search is read from the argv's `--search`. The translator's
   `Generating unsolvable task` lands here too, since the search then exhausts a
   trivially false goal.
 - SymK prints no exhaustion line. Its last `BOUND: L < U` line, with `L ≥ U`, is
@@ -291,14 +315,24 @@ where the code is ambiguous, into the same vocabulary as the Savile Row verdict.
   plan!`).
 
 **`exhausted` is this library's reading, not the planner's.** It is sound only
-if the search is complete and prunes safely. A relaxation heuristic prunes
-infinite-valued states even on a task with axioms, where infinity is not a
-dead end, so `astar(ff())` there "exhausts" without proving anything. The log
-cannot reveal this. From 26.6 the planner checks it (upstream issue1201): a
-safe exhaustion exits 11 and an unsafe one exits 12 with no exhaustion line, so
-`exhausted` only ever comes from older planners and SymK. Whether it becomes a
-run-level `unsat` is decided by the registry's `proves-unsat`, which a tune
-preset can switch off.
+if the search is complete and prunes safely. Before 26.6, a search prunes
+every state an evaluator calls a dead end, whether or not
+`dead_ends_are_reliable()`. So a relaxation heuristic on a task with axioms,
+where infinity is not a dead end, "exhausts" without proving anything. The log
+does show the pruning half, and `fd_verdict` checks it as 26.6 does:
+
+| evaluator in the logged search | dead ends unreliable when |
+|---|---|
+| `ff`, `add`, `hmax` | `Translator axioms:` is non-zero, or absent |
+| `cg`, `cea` | always |
+| `hm`, `lmcount` / `landmark_sum` | always: they are unreliable on tasks with conditional effects, which the log does not show |
+
+Any such evaluator gives `unknown`/`unsafe-pruning`. From 26.6 the planner
+checks it itself (upstream issue1201): a safe exhaustion exits 11 and an unsafe
+one exits 12 with no exhaustion line. So `exhausted` only ever comes from older
+planners and SymK. Completeness of the search algorithm itself (EHC, say) is
+left to the registry's `proves-unsat`, which a tune preset can switch off, and
+which decides whether `exhausted` becomes a run-level `unsat`.
 
 **The planner's own time limit is a timeout.** `search-limit` and
 `translate-limit` make `solve()` raise `TimeoutError`, exactly as a watchdog
@@ -335,6 +369,38 @@ verdict.
 - **Direct vs via-UPF**: the direct route passes `end_hint = duration -
   grounding_time`; the UPF route reuses the parser but passes no end hint.
 
+#### Verdicts: ENHSP exits 0 for almost everything
+
+ENHSP 0.21.0 exits 0 after a plan, after a proof, and after a run that failed to
+load its input. A missing domain file prints `Domain parsed`, then
+`Unsolvable Problem`, and exits 0. The exception goes to **stderr**. So
+`SolverStatsExtractor.enhsp_verdict` reads stdout and stderr, and
+`EnhspSolver` records the result on the `solving` phase, first match wins:
+
+| evidence | verdict | `verdict_reason` |
+|---|---|---|
+| `Problem Solved` | `sat` | |
+| `java.lang.OutOfMemoryError` (exit 1) | `unknown` | `memory` |
+| a logged exception (`SEVERE:`, `Exception in thread`) | `error` | `crash` |
+| `Some Syntax Error` (exit 255) | `error` | `input-error` |
+| any other non-zero exit | `error` | `crash` (signal) / `unexplained` |
+| `Problem unsolvable`, with `-anytime` / `-autoanytime` | `unknown` | `anytime` |
+| `Problem unsolvable`, with `-dl` | `unknown` | `bounded` |
+| `Problem unsolvable`, helpful actions (`sat-hmrph`, `sat-hmrphj`; or `-ha true` / `-ht true` with no `-planner`) | `unknown` | `incomplete` |
+| `Problem unsolvable`, otherwise | `unsat` | `exhausted` |
+| `Unsolvable Problem` (grounding returned nothing) | `unknown` | `grounding` |
+| none of these | `error` | `unexplained` |
+
+A `-planner` preset overrides `-ha` and `-ht`, as in ENHSP's own `setPlanner`.
+As with Fast Downward, `exhausted` becomes a run-level `unsat` only through
+`proves-unsat`.
+
+**Via UPF there is no verdict.** The UPF statuses are wrong in both directions:
+`up_enhsp` reports any exit 0 without a plan as `UNSOLVABLE_PROVEN`, and
+`up_fast_downward` reports any exit 12 as `UNSOLVABLE_INCOMPLETELY`. The UPF CLI
+is the consumer's, so if a consumer wants its UPF runs to conclude `unsat`, it
+must read the engine's log and record a verdict on the `solving` phase itself.
+
 ## invariants and conventions
 
 - **`duration` is ground truth; components are a subset.** Never assume the
@@ -389,8 +455,8 @@ proved. A status that stopped early (`timeout`, `hlim`, `stopped`) is never
 For a planner, being able to prove depends on the **search** as well as the model.
 `get_proves_unsat(model, tune=..., solver_name=...)` is the model's
 `proves-unsat` AND the effective tune's. A tune preset may carry
-`proves-unsat: false` (for example a relaxation heuristic that prunes unsafely
-on tasks with axioms), which takes the claim away. A tune can never grant it to
+`proves-unsat: false` (for example an incomplete search such as EHC, or an
+anytime portfolio), which takes the claim away. A tune can never grant it to
 a model that cannot prove. `finalize` keeps the value on the summary as
 `proves_unsat`, and a later `finalize` that passes None reuses it. So a
 re-finalize that folds in a late phase, as `horizon_utils` does, cannot drop it.
@@ -398,7 +464,7 @@ re-finalize that folds in a late phase, as `horizon_utils` does, cannot drop it.
 **A `solving` phase's verdict decides a completed run.** `failed` is the status
 of both a planner's proof and its crash, so `proves_unsat` alone would promote
 every crash of a complete model to `unsat`. Where the `solving` phase recorded a
-`verdict` (Fast Downward and SymK do, see above), it decides instead:
+`verdict` (Fast Downward, SymK and ENHSP do, see above), it decides:
 
 | verdict | `proves_unsat` | outcome |
 |---|---|---|
@@ -407,7 +473,15 @@ every crash of a complete model to `unsat`. Where the `solving` phase recorded a
 | `unknown` / `killed` | either | `unknown` |
 | `error` | either | `error` |
 
-A run with no verdict is read as before. Per-horizon verdicts
+| none | True | `unknown`: it may have been a proof, or a crash |
+| none | False | `error` |
+
+**No verdict, no `unsat`.** Without a verdict, a completed run's status is all
+there is to go on, and `failed` cannot tell a proof from a crash, so the run is
+`unknown` however complete the model. A UPF run is the usual case, and so is
+any consumer that drives a solver itself. To let such a run conclude `unsat`,
+record a verdict on its `solving` phase (`phase.solver_stats['verdict']`).
+Per-horizon verdicts
 (`solving-horizon-N`) are about one bound each and never decide the run.
 
 ## what the core owns
@@ -417,6 +491,7 @@ A run with no verdict is read as before. Per-horizon verdicts
 | per-solver stat parsers, cost-layer assembly, dispatch | `solver_stats.py` |
 | per-run Savile Row verdict (refuted vs gave up) | `solver_stats.py` (`savilerow_verdict`) |
 | per-run Fast Downward / SymK verdict (exit code + log) | `solver_stats.py` (`fd_verdict`) |
+| per-run ENHSP verdict (stdout + stderr) | `solver_stats.py` (`enhsp_verdict`) |
 | Savile Row `.info` split recording (per horizon) | `solver_horizon.py` (`_record_savilerow_times`) |
 | stats attached to a phase after each solve | `solver_runner.py`, `solver_horizon.py` |
 | the phase model (`RunSummary` / `PhaseResult`), outcome and success | `run_summary.py` |

{solver_support-0.4.0 → solver_support-0.4.2}/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.2"
 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.2}/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.2}/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.2}/solver_support/run_summary.py

@@ -245,13 +245,14 @@ class RunSummary:
         if final_status in _COMPLETED_STATUSES:
             verdict = self._solving_verdict()
             if verdict is None:
-                # No account of how the search ended, so read the status alone.
-                # The search finished and produced nothing. From a model that
-                # decides the problem that IS the answer; from any other model
-                # it means something went wrong, because a bounded model that
-                # finishes unsolved has not concluded anything -- it has merely
-                # stopped.
-                return 'unsat' if proves_unsat else 'error'
+                # No account of how the search ended, so the status is all
+                # there is, and it cannot prove anything: `failed` is equally
+                # what a proof, a rejected input and a crash look like. From a
+                # model that could prove, it may have been a proof, so the
+                # answer is unknown. From any other model, finishing unsolved
+                # means something went wrong. To conclude unsat, the solving
+                # phase must record a verdict.
+                return 'unknown' if proves_unsat else 'error'
             # The solver said how its search ended. Only a refutation from a
             # search that can prove one is a proof; an exhausted search that
             # cannot (an unsafe heuristic, a tune switched off) concluded

{solver_support-0.4.0 → solver_support-0.4.2}/solver_support/solver_enhsp.py

@@ -9,9 +9,10 @@ sas_plan, so the PDDLSolutionParser consumes the result unchanged.
 """
 
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict, Optional
 
 from .solver_base import Solver
+from .solver_stats import SolverStatsExtractor
 from .global_state import global_state
 
 
@@ -71,6 +72,17 @@ class EnhspSolver(Solver):
         # run_phase's expected_outputs, which would list it even on a failed parse.
         result = self.runner.run_phase("solving", cmd)
 
+        # ENHSP exits 0 for a proof and for a run that failed to load its input
+        # alike, so the summary's outcome is decided by this, not by `failed`.
+        verdict: Dict[str, Any] = {}
+        if not result.launch_failed:
+            verdict = SolverStatsExtractor.enhsp_verdict(
+                result.returncode, result.stdout, result.stderr, cmd,
+                timed_out=result.timed_out, interrupted=result.interrupted)
+            solving_phase = self.runner.summary.get_phase("solving")
+            if solving_phase is not None:
+                solving_phase.solver_stats.update(verdict)
+
         if result.timed_out:
             # No internal time limit outside anytime mode: the runner terminated
             # ENHSP mid-search, so no plan was written - a genuine timeout.
@@ -80,16 +92,19 @@ class EnhspSolver(Solver):
             self.logger.warning("ENHSP solving was interrupted")
             return self._finalise(solution_file)
 
-        if result.success:
-            return self._finalise(solution_file)
-
-        # ENHSP exits non-zero when it cannot parse the model (e.g. the axiom
-        # `pddl` domain, which it does not support) or fails to plan. A plan may
-        # still have been written on some paths, so salvage it if present.
-        salvaged = self._finalise(solution_file)
-        if salvaged is None:
-            self.logger.error(f"ENHSP solver failed: {result.stderr}")
-        return salvaged
+        # A plan may have been written even on a failing path, so take it if
+        # present. Without one, the verdict says whether anything went wrong:
+        # ENHSP exits 0 after a missing input file, and non-zero on a syntax
+        # error (e.g. the axioms it does not support) or out of memory.
+        plan = self._finalise(solution_file)
+        if plan is None:
+            failed = (verdict.get('verdict') == 'error' if verdict
+                      else not result.success)
+            if failed:
+                self.logger.error(f"ENHSP solver failed: {verdict} {result.stderr}")
+            else:
+                self.logger.info(f"ENHSP found no plan: {verdict}")
+        return plan
 
     def _finalise(self, solution_file: Path) -> Optional[Path]:
         """Register and return the plan file if ENHSP wrote one, else None."""