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

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: solver-support
-Version: 0.3.2
+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
 Project-URL: Homepage, https://github.com/ott2/solver-support
 Project-URL: Repository, https://github.com/ott2/solver-support
 Project-URL: Issues, https://github.com/ott2/solver-support/issues
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
@@ -48,8 +48,10 @@ consumer supplies:
 
 ## Status
 
-**Alpha.** The pipeline is in day-to-day use by several consumers and is covered
-by its own test suite, but the API may still shift between 0.x releases. Each
+**Beta.** The pipeline is in day-to-day use by several consumers and is covered
+by its own test suite. The injection seams and the run-summary vocabulary
+(`outcome`, `stop_reason`, `verdict`) are stable: later releases add to them
+rather than rename them. Other API may still shift between 0.x releases. Each
 release's changes are listed on the
 [releases page](https://github.com/ott2/solver-support/releases).
 
@@ -70,6 +72,37 @@ Requires Python 3.9 or newer (3.9.6 is the system Python on macOS, and is
 supported deliberately — each release is built and tested against it). The only
 runtime dependencies are `psutil` and `PyYAML`.
 
+## Quick start
+
+The package ships no model registry, but it carries a commented starter one
+(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
+from pathlib import Path
+from solver_support import (
+    write_starter_config, set_default_config_path, set_resource_root,
+    global_state, SolverRunner, FastDownwardSolver, fd_backstop,
+)
+
+config = write_starter_config("config/models.yaml")   # once; then edit it
+set_default_config_path(config)
+set_resource_root(".")            # where the models' `path:` entries resolve
+
+registry = global_state.model_registry
+runner = SolverRunner(instance="p01", model="pddl", solver="fd", timeout=60,
+                      timestamp="run1", summary_file=Path("p01.json"))
+try:
+    plan = FastDownwardSolver(runner).solve(
+        Path("p01.pddl"), model_path=str(registry.get_model_path("pddl")),
+        watchdog=fd_backstop(60))         # let the planner's own limit fire
+    status = "done" if plan else "failed"
+except TimeoutError:
+    status = "timeout"
+runner.finalize_summary(status, proves_unsat=registry.get_proves_unsat("pddl"))
+print(runner.summary.outcome)     # solved / unsat / unknown / error
+```
+
 ## Usage
 
 See [`docs/injection-api.md`](https://github.com/ott2/solver-support/blob/main/docs/injection-api.md)
@@ -125,4 +158,4 @@ config — that shape is the contract the loader implements.
 BSD-3-Clause — see
 [`LICENSE`](https://github.com/ott2/solver-support/blob/main/LICENSE).
 
-By András Salamon, with Claude Opus 4.8 and 5.
+By András Salamon, with Claude Opus 4.8, 5 and 5.5.

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

@@ -20,8 +20,10 @@ consumer supplies:
 
 ## Status
 
-**Alpha.** The pipeline is in day-to-day use by several consumers and is covered
-by its own test suite, but the API may still shift between 0.x releases. Each
+**Beta.** The pipeline is in day-to-day use by several consumers and is covered
+by its own test suite. The injection seams and the run-summary vocabulary
+(`outcome`, `stop_reason`, `verdict`) are stable: later releases add to them
+rather than rename them. Other API may still shift between 0.x releases. Each
 release's changes are listed on the
 [releases page](https://github.com/ott2/solver-support/releases).
 
@@ -42,6 +44,37 @@ Requires Python 3.9 or newer (3.9.6 is the system Python on macOS, and is
 supported deliberately — each release is built and tested against it). The only
 runtime dependencies are `psutil` and `PyYAML`.
 
+## Quick start
+
+The package ships no model registry, but it carries a commented starter one
+(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
+from pathlib import Path
+from solver_support import (
+    write_starter_config, set_default_config_path, set_resource_root,
+    global_state, SolverRunner, FastDownwardSolver, fd_backstop,
+)
+
+config = write_starter_config("config/models.yaml")   # once; then edit it
+set_default_config_path(config)
+set_resource_root(".")            # where the models' `path:` entries resolve
+
+registry = global_state.model_registry
+runner = SolverRunner(instance="p01", model="pddl", solver="fd", timeout=60,
+                      timestamp="run1", summary_file=Path("p01.json"))
+try:
+    plan = FastDownwardSolver(runner).solve(
+        Path("p01.pddl"), model_path=str(registry.get_model_path("pddl")),
+        watchdog=fd_backstop(60))         # let the planner's own limit fire
+    status = "done" if plan else "failed"
+except TimeoutError:
+    status = "timeout"
+runner.finalize_summary(status, proves_unsat=registry.get_proves_unsat("pddl"))
+print(runner.summary.outcome)     # solved / unsat / unknown / error
+```
+
 ## Usage
 
 See [`docs/injection-api.md`](https://github.com/ott2/solver-support/blob/main/docs/injection-api.md)
@@ -97,4 +130,4 @@ config — that shape is the contract the loader implements.
 BSD-3-Clause — see
 [`LICENSE`](https://github.com/ott2/solver-support/blob/main/LICENSE).
 
-By András Salamon, with Claude Opus 4.8 and 5.
+By András Salamon, with Claude Opus 4.8, 5 and 5.5.

{solver_support-0.3.2 → solver_support-0.4.1}/docs/injection-api.md

@@ -28,6 +28,12 @@ candidates bind when the registry is constructed rather than at import. Until a
 default config path is registered, constructing `ModelRegistry()` raises
 `ModelRegistryError` rather than guessing a consumer's config.
 
+To start a config from scratch, `write_starter_config(path)` writes out the
+commented starter registry that ships as package data (`starter_config_text()`
+returns its text). Writing it out wires nothing. The registry still raises until
+`set_default_config_path` names it, so a starter file on disk can never change
+what an unwired core does.
+
 ### 2. objective extraction (`solver_support.objective`)
 
 The core asks for a solution's objective at a few points but does not know how a

{solver_support-0.3.2 → solver_support-0.4.1}/docs/solver-runner.md

@@ -21,13 +21,15 @@ the pipeline branches on.
 
 ```python
 SolverResult(command, returncode, stdout, stderr, duration,
-             timed_out=False, interrupted=False)
+             timed_out=False, interrupted=False, launch_failed=False,
+             ok_returncodes=None)
 ```
 
 | field | meaning |
 |-------|---------|
 | `command: List[str]` | the command and arguments that ran |
-| `returncode: int` | process return code (0 for success) |
+| `returncode: int` | process return code |
+| `ok_returncodes` | the codes that count as success; `{0}` unless the caller says otherwise |
 | `stdout: str` / `stderr: str` | captured output, kept separate |
 | `duration: float` | **actual** seconds the command ran |
 | `timed_out: bool` | it was killed for exceeding the timeout |
@@ -54,9 +56,30 @@ a component of it — see the invariants in [`timing-model.md`](timing-model.md)
 
 ### properties
 
-- `success: bool` — completed with return code 0, no timeout, no interruption.
+- `success: bool` — exited with one of its `ok_returncodes`, no timeout, no
+  interruption, no launch failure.
 - `failed: bool` — the inverse; useful as a direct `if` on a run.
 
+### solvers that answer through the exit code
+
+Some solvers put the *answer* in the exit code, so for them a non-zero exit is
+the solver doing its job. Every DIMACS SAT solver exits 10 for SATISFIABLE and
+20 for UNSATISFIABLE; read against `{0}`, a refutation would be logged as
+`Command failed` and recorded as `success=False`. Pass the solver's set to `run`
+or `run_phase`:
+
+```python
+from solver_support.solver_runner import DIMACS_SAT_RETURNCODES
+
+result = runner.run(['kissat', 'model.cnf'], ok_returncodes=DIMACS_SAT_RETURNCODES)
+result.success      # True for 0 (unknown), 10 (sat) and 20 (unsat)
+result.returncode   # which of them
+```
+
+`success` then means "the process ran and answered", not what the answer was:
+read `returncode` (or the parsed stats) for that. The runner never picks the set
+by detecting the solver from the command, so detection cannot decide success.
+
 Note that `failed` covers three *different* outcomes, and the pipeline usually
 cares which: check `timed_out` and `interrupted` before treating a run as a
 genuine solver failure. A timed-out anytime solver may still have banked a

{solver_support-0.3.2 → 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
@@ -238,6 +258,73 @@ N+1. Only the registry knows which models decide the problem itself
 - **Timeout**: the final, cut-off layer is bounded by `end_hint = duration -
   translate_time` (the search-relative kill time), so the blown-up deepest bound
   does not collapse to ~0.
+- **Its own limit, and the backstop above it**: `--search-time-limit T` is a CPU
+  rlimit on the search alone, while the runner's watchdog counts wall clock over
+  translation plus search. A watchdog at `T` therefore always fires first, and
+  the run loses the exit 23 and the final statistics block it would have
+  written. Size the watchdog with `fd_backstop(T, translate_allowance)`, which
+  is `T`, plus translation, plus `FD_EXIT_GRACE`, and pass it as
+  `FastDownwardSolver.solve(..., watchdog=...)`. The runner's own timeout stays
+  the in-band limit. Then an external kill once again means the planner ignored
+  its limit. As with Savile Row, this is a
+  backstop and not a budget: to hold a run to a wall-clock `T`, shrink the search
+  limit.
+
+#### Verdicts: proof, limit, or rejection
+
+Fast Downward answers through its **exit code** (`driver/returncodes.py`), so
+`run_phase` is handed `FD_ANSWER_RETURNCODES` and a proof is not logged as a
+failed command. `SolverStatsExtractor.fd_verdict` reads the code, plus the log
+where the code is ambiguous, into the same vocabulary as the Savile Row verdict.
+`FastDownwardSolver` records it on the `solving` phase:
+
+| exit | verdict | `verdict_reason` |
+|---|---|---|
+| 0–3 (plan; 1–3 then hit a limit) | `sat` | |
+| 10, 11 | `unsat` | (the planner's own claim) |
+| 12, see below | `unsat` / `unknown` | `exhausted`, or `search-limit` / `bounded` / `portfolio` / `incomplete` |
+| 13 (26.6+) | `unknown` | `bounded` |
+| 20 / 21 | `unknown` | `translate-memory` / `translate-limit` |
+| 22, 24 / 23 | `unknown` | `memory` / `search-limit` |
+| 34, 37 | `error` | `unsupported` (`unknown`/`portfolio` for an anytime portfolio) |
+| 31, 33, 36 | `error` | `input-error` |
+| 30, 32, 35, a signal | `error` | `crash` |
+| killed by the runner | `killed` | |
+
+**Exit 12 is ambiguous by construction.** Before 26.6 the planner exits
+`found_solution() ? 0 : 12` however the search ended, so the log decides:
+
+- `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
+  `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
+  `exhausted` when `U` is infinity (`2147483647`) and `bounded` otherwise.
+- A portfolio's 12 is always `portfolio`. It can mask its components'
+  time-outs, and its exhaustion line may come from a component that pruned
+  unsafely.
+- Anything else is `incomplete`: EHC giving up, or a 26.6 search that the
+  planner itself judged incomplete (`Search terminated without finding a
+  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.
+
+**The planner's own time limit is a timeout.** `search-limit` and
+`translate-limit` make `solve()` raise `TimeoutError`, exactly as a watchdog
+kill does, and so does an anytime portfolio that ends without a plan. Every other
+no-plan ending returns `None`, and the run's `outcome` is derived from the
+verdict.
 
 ### UPF (via the consumer's UPF CLI; PDDL or constructed models)
 
@@ -319,16 +406,41 @@ run is ever concluded unsat, which understates rather than overstates what was
 proved. A status that stopped early (`timeout`, `hlim`, `stopped`) is never
 `unsat` however complete the model.
 
+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
+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.
+
+**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 | `proves_unsat` | outcome |
+|---|---|---|
+| `unsat` | True | `unsat` |
+| `unsat` | False | `unknown`: the search ran out, but cannot prove |
+| `unknown` / `killed` | either | `unknown` |
+| `error` | either | `error` |
+
+A run with no verdict is read as before. Per-horizon verdicts
+(`solving-horizon-N`) are about one bound each and never decide the run.
+
 ## what the core owns
 
 | concern | location |
 |---------|----------|
 | 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`) |
 | 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` |
-| relating the in-band limits to the external kill | `command_builders.py` (`savilerow_backstop`) |
+| relating the in-band limits to the external kill | `command_builders.py` (`savilerow_backstop`, `fd_backstop`) |
 
 Turning these per-phase stats into a unified per-horizon curve for display, a
 single "preprocess" baseline, and plots is the **consumer's** job — it reads the

{solver_support-0.3.2 → 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.3.2"
+version = "0.4.1"
 description = "Generic Conjure / Savile Row / Fast Downward / SymK / ENHSP / UPF solver pipeline"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -29,7 +29,7 @@ authors = [
     {name = "András Salamon"},
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
@@ -81,6 +81,11 @@ zip-safe = false
 [tool.setuptools.packages.find]
 include = ["solver_support*"]
 
+# The starter registry `write_starter_config` copies out. Package data, not a
+# default: nothing loads it unless a user writes it out and wires it.
+[tool.setuptools.package-data]
+solver_support = ["starter/*.yaml"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]

{solver_support-0.3.2 → solver_support-0.4.1}/solver_support/__init__.py

@@ -45,8 +45,12 @@ from .model_registry import (
     set_default_config_path,
     set_resource_root,
     set_user_config_finder,
+    starter_config_text,
+    write_starter_config,
+)
+from .command_builders import (
+    savilerow_backstop, SAVILEROW_FLUSH_GRACE, fd_backstop, FD_EXIT_GRACE,
 )
-from .command_builders import savilerow_backstop, SAVILEROW_FLUSH_GRACE
 
 # --- run configuration singleton ---
 from .global_state import global_state, GlobalState
@@ -68,8 +72,12 @@ from .solver_upfplan import UpfPlanSolver
 from .solver_horizon import HorizonBasedSolver, SavileRowSolver, ConjureSolver
 
 # --- execution, stats, run model ---
-from .solver_runner import SolverRunner, SolverResult, SolverExecutableError
-from .solver_stats import SolverStatsExtractor, detect_solver_from_command
+from .solver_runner import (
+    SolverRunner, SolverResult, SolverExecutableError, DIMACS_SAT_RETURNCODES,
+)
+from .solver_stats import (
+    SolverStatsExtractor, detect_solver_from_command, FD_ANSWER_RETURNCODES,
+)
 from .run_summary import RunSummary, PhaseResult, create_run_summary
 
 # --- file naming and horizon loop ---
@@ -107,8 +115,12 @@ __all__ = [
     "set_default_config_path",
     "set_resource_root",
     "set_user_config_finder",
+    "starter_config_text",
+    "write_starter_config",
     "savilerow_backstop",
     "SAVILEROW_FLUSH_GRACE",
+    "fd_backstop",
+    "FD_EXIT_GRACE",
     # run config
     "global_state",
     "GlobalState",
@@ -130,6 +142,8 @@ __all__ = [
     "SolverRunner",
     "SolverResult",
     "SolverExecutableError",
+    "DIMACS_SAT_RETURNCODES",
+    "FD_ANSWER_RETURNCODES",
     "SolverStatsExtractor",
     "detect_solver_from_command",
     "RunSummary",

{solver_support-0.3.2 → solver_support-0.4.1}/solver_support/command_builders.py

@@ -56,6 +56,35 @@ def savilerow_backstop(timeout: int, solver_timeout: Optional[int] = None,
     return timeout + (timeout if solver_timeout is None else solver_timeout) + grace
 
 
+#: Seconds of slack above Fast Downward's in-band search limit. The driver turns
+#: SIGXCPU into exit 23 and the search then prints its final statistics block
+#: ("Actual search time", expansions); the grace lets that land. It is also what
+#: absorbs the gap between the CPU seconds the limit counts and the wall-clock
+#: seconds the watchdog counts, which a loaded machine widens.
+FD_EXIT_GRACE = 30
+
+
+def fd_backstop(timeout: int, translate_allowance: Optional[int] = None,
+                grace: int = FD_EXIT_GRACE) -> int:
+    """The external timeout that cannot preempt Fast Downward's own limit.
+
+    :meth:`build_fd_command` passes ``--search-time-limit T``, a CPU rlimit
+    on the *search* alone, while the runner's watchdog kills at ``T`` seconds of
+    wall clock over translation *plus* search. CPU time never exceeds the wall
+    time since search began, so a watchdog at ``T`` always fires first and the
+    in-band limit never gets to: the run is SIGTERMed instead of exiting 23, its
+    statistics are lost, and its verdict can only say ``killed``.
+
+    Sized like :func:`savilerow_backstop`: the search limit, plus what
+    translation may take before it (``translate_allowance``, defaulting to the
+    search limit, since translation is unbounded in band and only the caller
+    knows its cost), plus grace. The same caveat applies: this is a backstop,
+    not a wall-clock budget. To hold a run to ``T``, shrink the search limit.
+    """
+    allowance = timeout if translate_allowance is None else translate_allowance
+    return timeout + allowance + grace
+
+
 class CommandBuilderMixin:
     """The ``build_*_command`` methods mixed into :class:`ModelRegistry`."""
 

{solver_support-0.3.2 → 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: