Factor bundle replay into BundleReplay helper; unify solve/extract/MCP

Codex review item 4. Before: `solve_bundle` (CLI), `solve_bundle_inner`
(MCP), and `extract` each had their own copy of the "load bundle, validate,
reconstruct ReductionPath, call reduce_along_path" flow — three places to
drift out of sync, and only `extract` had the endpoint-vs-source/target
validation added in the previous commit.

Now `BundleReplay::prepare` is the single entry point: validates
bundle.path length and endpoint consistency with source/target, loads both
problems, rebuilds the path, and replays to a `ReductionChain`. Callers
just pick their own way to produce a target config (solver vs external
input) and call `replay.extract(target_config)`.

Benefit: the malformed-bundle check now protects `pred solve` and the MCP
bundle-solve tool too, not just `pred extract`.

Also: tests derive the target config from `pred solve --solver brute-force`
instead of hardcoding it, so they pass under both default and `--features
mcp` builds (which pick different reduction paths, MIS->...->ILP->QUBO vs
MIS->...->MaxSetPacking->QUBO).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: isPANN

problemreductions-cli/src/commands/extract.rs

@@ -1,7 +1,6 @@
-use crate::dispatch::{load_problem, read_input, ReductionBundle};
+use crate::dispatch::{read_input, BundleReplay, ReductionBundle};
 use crate::output::OutputConfig;
 use anyhow::{Context, Result};
-use problemreductions::rules::{ReductionGraph, ReductionPath, ReductionStep};
 use std::path::Path;
 
 /// Extract a source-space configuration from a target-space configuration and a reduction bundle.
@@ -40,42 +39,14 @@ pub fn extract(input: &Path, config_str: &str, out: &OutputConfig) -> Result<()>
             .collect::<Result<Vec<_>>>()?
     };
 
-    // Validate bundle self-consistency before trusting it.
-    if bundle.path.len() < 2 {
-        anyhow::bail!(
-            "Malformed bundle: `path` must contain at least two steps (source and target), got {}",
-            bundle.path.len()
-        );
-    }
-    let first = bundle.path.first().unwrap();
-    let last = bundle.path.last().unwrap();
-    if first.name != bundle.source.problem_type || first.variant != bundle.source.variant {
-        anyhow::bail!(
-            "Malformed bundle: path starts with {} but source is {}",
-            format_step(&first.name, &first.variant),
-            format_step(&bundle.source.problem_type, &bundle.source.variant),
-        );
-    }
-    if last.name != bundle.target.problem_type || last.variant != bundle.target.variant {
-        anyhow::bail!(
-            "Malformed bundle: path ends with {} but target is {}",
-            format_step(&last.name, &last.variant),
-            format_step(&bundle.target.problem_type, &bundle.target.variant),
-        );
-    }
+    let replay = BundleReplay::prepare(&bundle)?;
 
-    let target = load_problem(
-        &bundle.target.problem_type,
-        &bundle.target.variant,
-        bundle.target.data.clone(),
-    )?;
-    let target_name = target.problem_name().to_string();
-    let target_dims = target.dims_dyn();
+    let target_dims = replay.target.dims_dyn();
     if target_config.len() != target_dims.len() {
         anyhow::bail!(
             "Target config has {} values but target problem {} has {} variables",
             target_config.len(),
-            target_name,
+            replay.target_name,
             target_dims.len()
         );
     }
@@ -87,71 +58,30 @@ pub fn extract(input: &Path, config_str: &str, out: &OutputConfig) -> Result<()>
             );
         }
     }
-    let target_eval = target.evaluate_dyn(&target_config);
+    let target_eval = replay.target.evaluate_dyn(&target_config);
 
-    let source = load_problem(
-        &bundle.source.problem_type,
-        &bundle.source.variant,
-        bundle.source.data.clone(),
-    )?;
-    let source_name = source.problem_name().to_string();
-
-    let graph = ReductionGraph::new();
-    let reduction_path = ReductionPath {
-        steps: bundle
-            .path
-            .iter()
-            .map(|s| ReductionStep {
-                name: s.name.clone(),
-                variant: s.variant.clone(),
-            })
-            .collect(),
-    };
-
-    let chain = graph
-        .reduce_along_path(&reduction_path, source.as_any())
-        .ok_or_else(|| {
-            anyhow::anyhow!(
-                "Bundle extraction requires a witness-capable reduction path; \
-                 this bundle's path cannot map a target solution back to the source."
-            )
-        })?;
-
-    let source_config = chain.extract_solution(&target_config);
-    let source_eval = source.evaluate_dyn(&source_config);
+    let (source_config, source_eval) = replay.extract(&target_config);
 
     let text = format!(
         "Problem: {}\nSolver: external (via {})\nSolution: {:?}\nEvaluation: {}",
-        source_name, target_name, source_config, source_eval,
+        replay.source_name, replay.target_name, source_config, source_eval,
     );
 
     // Schema aligned with `pred solve` on a bundle: `problem`, `reduced_to`, `solution`,
     // `evaluation`, `intermediate { problem, solution, evaluation }`. `solver` is "external"
     // to signal that pred did not run a solver — the target config came from outside.
     let json = serde_json::json!({
-        "problem": source_name,
+        "problem": replay.source_name,
         "solver": "external",
-        "reduced_to": target_name,
+        "reduced_to": replay.target_name,
         "solution": source_config,
         "evaluation": source_eval,
         "intermediate": {
-            "problem": target_name,
+            "problem": replay.target_name,
             "solution": target_config,
             "evaluation": target_eval,
         },
     });
 
     out.emit_with_default_name("pred_extract.json", &text, &json)
 }
-
-fn format_step(name: &str, variant: &std::collections::BTreeMap<String, String>) -> String {
-    if variant.is_empty() {
-        name.to_string()
-    } else {
-        let parts: Vec<String> = variant
-            .iter()
-            .map(|(k, v)| format!("{}={}", k, v))
-            .collect();
-        format!("{}{{{}}}", name, parts.join(", "))
-    }
-}

problemreductions-cli/src/commands/solve.rs

@@ -1,7 +1,6 @@
-use crate::dispatch::{load_problem, read_input, ProblemJson, ReductionBundle};
+use crate::dispatch::{load_problem, read_input, BundleReplay, ProblemJson, ReductionBundle};
 use crate::output::OutputConfig;
 use anyhow::{Context, Result};
-use problemreductions::rules::ReductionGraph;
 use std::path::Path;
 use std::time::Duration;
 
@@ -166,75 +165,39 @@ fn solve_problem(
 
 /// Solve a reduction bundle: solve the target problem, then map the solution back.
 fn solve_bundle(bundle: ReductionBundle, solver_name: &str, out: &OutputConfig) -> Result<()> {
-    // 1. Load the target problem from the bundle
-    let target = load_problem(
-        &bundle.target.problem_type,
-        &bundle.target.variant,
-        bundle.target.data.clone(),
-    )?;
-    let target_name = target.problem_name();
+    let replay = BundleReplay::prepare(&bundle)?;
 
-    // 2. Solve the target problem
     let target_result = match solver_name {
-        "brute-force" => target.solve_brute_force_witness().ok_or_else(|| {
+        "brute-force" => replay.target.solve_brute_force_witness().ok_or_else(|| {
             anyhow::anyhow!(
                 "Bundle solving requires a witness-capable target problem and witness-capable reduction path; {} only supports aggregate-value solving.",
-                target_name
+                replay.target_name
             )
         })?,
-        "ilp" => target.solve_with_ilp().map_err(add_ilp_solver_hint)?,
-        "customized" => target
+        "ilp" => replay.target.solve_with_ilp().map_err(add_ilp_solver_hint)?,
+        "customized" => replay
+            .target
             .solve_with_customized()
             .map_err(add_customized_solver_hint)?,
         _ => unreachable!(),
     };
 
-    // 3. Load source problem and re-execute the reduction chain to get extract_solution
-    let source = load_problem(
-        &bundle.source.problem_type,
-        &bundle.source.variant,
-        bundle.source.data.clone(),
-    )?;
-    let source_name = source.problem_name();
+    let (source_config, source_eval) = replay.extract(&target_result.config);
 
-    let graph = ReductionGraph::new();
-
-    // Reconstruct the ReductionPath from the bundle's path steps
-    let reduction_path = problemreductions::rules::ReductionPath {
-        steps: bundle
-            .path
-            .iter()
-            .map(|s| problemreductions::rules::ReductionStep {
-                name: s.name.clone(),
-                variant: s.variant.clone(),
-            })
-            .collect(),
-    };
-
-    let chain = graph
-        .reduce_along_path(&reduction_path, source.as_any())
-        .ok_or_else(|| anyhow::anyhow!(
-            "Bundle solving requires a witness-capable reduction path; this bundle cannot recover a source solution."
-        ))?;
-
-    // 4. Extract solution back to source problem space
-    let source_config = chain.extract_solution(&target_result.config);
-    let source_eval = source.evaluate_dyn(&source_config);
-
-    let solver_desc = format!("{} (via {})", solver_name, target_name);
+    let solver_desc = format!("{} (via {})", solver_name, replay.target_name);
     let text = format!(
         "Problem: {}\nSolver: {}\nSolution: {:?}\nEvaluation: {}",
-        source_name, solver_desc, source_config, source_eval,
+        replay.source_name, solver_desc, source_config, source_eval,
     );
 
     let json = serde_json::json!({
-        "problem": source_name,
+        "problem": replay.source_name,
         "solver": solver_name,
-        "reduced_to": target_name,
+        "reduced_to": replay.target_name,
         "solution": source_config,
         "evaluation": source_eval,
         "intermediate": {
-            "problem": target_name,
+            "problem": replay.target_name,
             "solution": target_result.config,
             "evaluation": target_result.evaluation,
         },

problemreductions-cli/src/dispatch.rs

@@ -114,6 +114,111 @@ impl LoadedProblem {
     }
 }
 
+/// A validated reduction bundle ready to replay:
+/// source, target, and the reconstructed reduction chain. Construct via
+/// [`BundleReplay::prepare`]. All three CLI/MCP bundle workflows
+/// (`pred solve <bundle>`, `pred extract <bundle>`, MCP `solve_problem`)
+/// share this setup so validation and error text stay in sync.
+pub struct BundleReplay {
+    pub source: LoadedProblem,
+    pub source_name: String,
+    pub target: LoadedProblem,
+    pub target_name: String,
+    pub chain: problemreductions::rules::ReductionChain,
+}
+
+impl BundleReplay {
+    /// Validate the bundle and replay the reduction chain.
+    ///
+    /// Checks: `path` has at least two steps; `path[0]` matches `source`;
+    /// `path[-1]` matches `target`. Then loads both problems, reconstructs
+    /// the `ReductionPath`, and calls `reduce_along_path`. Returns an error
+    /// (not a panic) for malformed bundles or aggregate-only paths.
+    pub fn prepare(bundle: &ReductionBundle) -> Result<Self> {
+        if bundle.path.len() < 2 {
+            anyhow::bail!(
+                "Malformed bundle: `path` must contain at least two steps (source and target), got {}",
+                bundle.path.len()
+            );
+        }
+        let first = bundle.path.first().unwrap();
+        let last = bundle.path.last().unwrap();
+        if first.name != bundle.source.problem_type || first.variant != bundle.source.variant {
+            anyhow::bail!(
+                "Malformed bundle: path starts with {} but source is {}",
+                format_step(&first.name, &first.variant),
+                format_step(&bundle.source.problem_type, &bundle.source.variant),
+            );
+        }
+        if last.name != bundle.target.problem_type || last.variant != bundle.target.variant {
+            anyhow::bail!(
+                "Malformed bundle: path ends with {} but target is {}",
+                format_step(&last.name, &last.variant),
+                format_step(&bundle.target.problem_type, &bundle.target.variant),
+            );
+        }
+
+        let source = load_problem(
+            &bundle.source.problem_type,
+            &bundle.source.variant,
+            bundle.source.data.clone(),
+        )?;
+        let source_name = source.problem_name().to_string();
+
+        let target = load_problem(
+            &bundle.target.problem_type,
+            &bundle.target.variant,
+            bundle.target.data.clone(),
+        )?;
+        let target_name = target.problem_name().to_string();
+
+        let reduction_path = problemreductions::rules::ReductionPath {
+            steps: bundle
+                .path
+                .iter()
+                .map(|s| problemreductions::rules::ReductionStep {
+                    name: s.name.clone(),
+                    variant: s.variant.clone(),
+                })
+                .collect(),
+        };
+
+        let graph = ReductionGraph::new();
+        let chain = graph
+            .reduce_along_path(&reduction_path, source.as_any())
+            .ok_or_else(|| anyhow::anyhow!(
+                "Bundle requires a witness-capable reduction path; this bundle cannot map a target solution back to the source."
+            ))?;
+
+        Ok(Self {
+            source,
+            source_name,
+            target,
+            target_name,
+            chain,
+        })
+    }
+
+    /// Map a target-space configuration back to the source space and evaluate it.
+    pub fn extract(&self, target_config: &[usize]) -> (Vec<usize>, String) {
+        let source_config = self.chain.extract_solution(target_config);
+        let source_eval = self.source.evaluate_dyn(&source_config);
+        (source_config, source_eval)
+    }
+}
+
+fn format_step(name: &str, variant: &BTreeMap<String, String>) -> String {
+    if variant.is_empty() {
+        name.to_string()
+    } else {
+        let parts: Vec<String> = variant
+            .iter()
+            .map(|(k, v)| format!("{}={}", k, v))
+            .collect();
+        format!("{}{{{}}}", name, parts.join(", "))
+    }
+}
+
 /// Load a problem from JSON type/variant/data.
 pub fn load_problem(
     name: &str,