@@ -140,8 +140,11 @@ endpoint default to `TYPESAFE_DEFAULT_MODEL` and `TYPESAFE_BASE_URL`, or `jev-la
 and `https://api.typesafe.ai`. A client passed to `Decide(..., client=...)` takes
 precedence over `dspy.settings.system_one`; no text LM is needed.
 
-`Decide` participates in module composition, `named_predictors()`, callbacks,
-traces, `batch`, and `acall`. It validates required inputs and rejects unknown
+`Decide` inherits from `Module` and `Parameter`, not `Predict`. It participates in
+module composition, `named_parameters()`, callbacks, traces, `batch`, and `acall`.
+`named_predictors()` excludes it, so predictor-specific optimizers can target the
+`Predict` leaves of a mixed program without attaching demonstrations to `Decide`.
+It validates required inputs and rejects unknown
 inputs and unsupported outputs. Signature task instructions and field descriptions
 are included in each provider question. `Decide` does not support demonstrations:
 passing `demos=` or attaching nonempty `.demos` raises before inference. Optimizers
@@ -162,6 +165,10 @@ restored.load("assess.json")
 ```
 
 State-only loading requires the same signature architecture, as with `Predict`.
+Saved state contains only `signature`, `thresholds`, `weights`, and `client`.
+`reset()` preserves configuration because there is no demonstration or training
+state to clear. `reset_copy()` makes an independent copy with the same settings,
+so predictor-specific optimizers do not erase tuned decision parameters.
 Parameters survive this round trip; demonstrations are not saved, and loading
 state with nonempty demonstrations raises rather than silently discarding them. Explicit TypeSafe
 client settings are saved without API keys; credentials come from the environment
 
@@ -10,14 +10,17 @@
 from dspy.adapters.utils import get_field_description_string
 from dspy.clients.typesafe import TypeSafe
 from dspy.dsp.utils.settings import settings
-from dspy.predict.predict import Predict, _sanitize_lm_state, serialize_object
+from dspy.predict.parameter import Parameter
+from dspy.predict.predict import _sanitize_lm_state, serialize_object
+from dspy.primitives.module import Module
+from dspy.primitives.prediction import Prediction
 from dspy.signatures.signature import Signature, ensure_signature
 from dspy.utils.annotation import experimental
 from dspy.utils.callback import BaseCallback
 
 
 @experimental
-class Decide(Predict):
+class Decide(Module, Parameter):
     """Answer a signature's closed-set outputs in one System One request.
 
     Declare outputs using Noul, Score[(number, description), ...], and
@@ -47,7 +50,8 @@ def __init__(
         client: TypeSafe | None = None,
         callbacks: list[BaseCallback] | None = None,
     ):
-        super().__init__(signature, callbacks=callbacks)
+        super().__init__(callbacks=callbacks)
+        self.signature = ensure_signature(signature)
         self.client = client
         types = self._output_types(self.signature)
         self.thresholds = {name: 0.5 for name, kind in types.items() if kind is Noul}
@@ -56,6 +60,9 @@ def __init__(
             {name: {str(v): 1.0 for v, _ in kind.options} for name, kind in types.items() if issubclass(kind, Choice)}
         )
 
+    def reset(self):
+        """Keep configuration intact: Decide has no demonstration or training state to reset."""
+
     @staticmethod
     def _output_types(signature):
         if not signature.output_fields:
@@ -128,7 +135,7 @@ def _questions(self, signature, types):
     def _prepare(self, kwargs):
         trace = kwargs.pop("_trace", True)
         signature = ensure_signature(kwargs.pop("signature", self.signature))
-        if "demos" in kwargs or self.demos:
+        if "demos" in kwargs or getattr(self, "demos", None):
             raise ValueError("Decide does not support demonstrations.")
         client = self.client if self.client is not None else settings.system_one
         if client is None:
@@ -204,7 +211,12 @@ def _decode(self, answers, signature, types, inputs, trace):
                     probabilities=answer["probabilities"],
                 )
             outputs[name] = result if field.annotation is kind else result.value
-        return self._forward_postprocess([outputs], signature, _trace=trace, **inputs)
+        prediction = Prediction.from_completions([outputs], signature=signature)
+        if trace and settings.trace is not None and settings.max_trace_size > 0:
+            if len(settings.trace) >= settings.max_trace_size:
+                settings.trace.pop(0)
+            settings.trace.append((self, inputs, prediction))
+        return prediction
 
     def forward(self, **kwargs):
         client, signature, types, inputs, questions, trace = self._prepare(kwargs)
@@ -217,26 +229,28 @@ async def aforward(self, **kwargs):
         return self._decode(answers, signature, types, inputs, trace)
 
     def dump_state(self, json_mode=True):
-        if self.demos:
+        if getattr(self, "demos", None):
             raise ValueError("Decide does not support demonstrations.")
-        state = super().dump_state(json_mode=json_mode)
-        state.pop("demos")
-        state["thresholds"] = copy.deepcopy(self.thresholds)
-        state["weights"] = copy.deepcopy(self.weights)
         if self.client is not None and not isinstance(self.client, TypeSafe):
             raise TypeError(
                 "Saving an explicit Decide client requires dspy.experimental.TypeSafe; configure custom clients in settings."
             )
-        state["client"] = self.client.dump_state() if self.client is not None else None
-        return state
+        return {
+            "signature": self.signature.dump_state(),
+            "thresholds": copy.deepcopy(self.thresholds),
+            "weights": copy.deepcopy(self.weights),
+            "client": self.client.dump_state() if self.client is not None else None,
+        }
 
     def load_state(self, state, *, allow_unsafe_lm_state=False):
         state = copy.deepcopy(state)
         if state.pop("demos", None):
             raise ValueError("Decide does not support demonstrations.")
         client_state = state.pop("client", None)
-        super().load_state(state, allow_unsafe_lm_state=allow_unsafe_lm_state)
-        self.demos = []
+        self.signature = self.signature.load_state(state["signature"])
+        self.thresholds = state["thresholds"]
+        self.weights = state["weights"]
+        self.__dict__.pop("demos", None)
         self.client = TypeSafe(**_sanitize_lm_state(client_state, allow_unsafe_lm_state)) if client_state else None
         self._validate_parameters(self._output_types(self.signature))
         return self
@@ -331,7 +331,7 @@ def forward(self, text):
     program = Pipeline()
     client = FakeClient()
     callback = Callback()
-    assert program.named_predictors() == [("decide", program.decide)]
+    assert program.named_predictors() == []
     assert program.named_parameters() == [("decide", program.decide)]
     trace = []
     with dspy.context(system_one=client, trace=trace, max_trace_size=1, callbacks=[callback]):
@@ -393,7 +393,7 @@ def test_copy_and_json_state_preserve_config(tmp_path):
     restored.load(path)
     assert restored.weights == module.weights
     assert restored.thresholds == module.thresholds
-    assert "demos" not in module.dump_state()
+    assert set(module.dump_state()) == {"signature", "thresholds", "weights", "client"}
     with dspy.context(system_one=FakeClient()):
         assert restored(text="next").toDict() == before.toDict()
 
@@ -419,10 +419,65 @@ async def test_reject_demonstrations_before_inference_or_saving():
             module.dump_state()
         assert client.calls == []
         module.load_state({**state, "demos": []})
-        assert module.demos == []
+        assert not hasattr(module, "demos")
         assert module(text="x").flag is True
 
 
+def test_mixed_program_discovery_optimizer_and_persistence(tmp_path):
+    from dspy.utils.dummies import DummyLM
+
+    class Pipeline(dspy.Module):
+        def __init__(self):
+            self.nodes = {"decision": Decide("text -> flag: bool")}
+            self.explain = dspy.Predict("flag: bool -> explanation: str")
+
+        def forward(self, text):
+            return self.explain(flag=self.nodes["decision"](text=text).flag)
+
+    program = Pipeline()
+    decision = program.nodes["decision"]
+    decision.thresholds["flag"] = 0.9
+    assert not isinstance(decision, dspy.Predict)
+    assert decision.named_parameters() == [("self", decision)]
+    assert not hasattr(decision, "demos")
+    assert program.named_parameters() == [("nodes['decision']", decision), ("explain", program.explain)]
+    assert program.named_predictors() == [("explain", program.explain)]
+    trained = dspy.LabeledFewShot(k=1).compile(
+        program, trainset=[dspy.Example(flag=False, explanation="Below threshold").with_inputs("flag")]
+    )
+    assert len(trained.explain.demos) == 1
+    assert not hasattr(trained.nodes["decision"], "demos")
+    assert trained.nodes["decision"].thresholds == {"flag": 0.9}
+    path = tmp_path / "mixed.json"
+    trained.save(path)
+    restored = Pipeline()
+    restored.load(path)
+    assert restored.nodes["decision"].thresholds == {"flag": 0.9}
+    assert len(restored.explain.demos) == 1
+    trace = []
+    with dspy.context(system_one=FakeClient(), lm=DummyLM([{"explanation": "Below threshold"}]), trace=trace):
+        assert restored(text="x").explanation == "Below threshold"
+    assert [step[0] for step in trace] == [restored.nodes["decision"], restored.explain]
+    assert trace[1][1] == {"flag": False}
+
+
+def test_reset_copy_preserves_configuration_without_aliasing():
+    module = decide(True, client=TypeSafe("jev-test"))
+    module.thresholds["flag"] = 0.9
+    module.weights["rating"] = [-2, 0, 8]
+    module.weights["label"] = {"other": 3}
+    reset = module.reset_copy()
+    assert reset.thresholds == {"flag": 0.9}
+    assert reset.weights == {"rating": [-2, 0, 8], "label": {"other": 3}}
+    assert reset.signature is module.signature
+    assert reset.client.model == "jev-test"
+    reset.thresholds["flag"] = 0.5
+    reset.weights["rating"][1] = 1
+    reset.weights["label"]["other"] = 1
+    assert module.thresholds == {"flag": 0.9}
+    assert module.weights == {"rating": [-2, 0, 8], "label": {"other": 3}}
+
+
 def test_explicit_client_state_omits_key_and_gates_endpoint(tmp_path):
     module = decide(client=TypeSafe("jev-test", api_key="test-credential", base_url="https://example.test"))
     path = tmp_path / "decide.json"